1#![allow(
5 non_camel_case_types,
6 unused,
7 non_snake_case,
8 clippy::needless_return,
9 clippy::redundant_closure_call,
10 clippy::redundant_closure,
11 clippy::useless_conversion,
12 clippy::unit_arg,
13 clippy::unused_unit,
14 clippy::double_parens,
15 clippy::let_and_return,
16 clippy::too_many_arguments,
17 clippy::match_single_binding,
18 clippy::clone_on_copy,
19 clippy::let_unit_value,
20 clippy::deref_addrof,
21 clippy::explicit_auto_deref,
22 clippy::borrow_deref_ref,
23 clippy::needless_borrow
24)]
25
26use crate::bindings::*;
29use crate::model::EventListener;
30use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
31use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
32use flutter_rust_bridge::{Handler, IntoIntoDart};
33
34flutter_rust_bridge::frb_generated_boilerplate!(
37 default_stream_sink_codec = DcoCodec,
38 default_rust_opaque = RustOpaqueNom,
39 default_rust_auto_opaque = RustAutoOpaqueNom,
40);
41pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.9.0";
42pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 1264782025;
43
44flutter_rust_bridge::frb_generated_default_handler!();
47
48fn wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(
51 port_: flutter_rust_bridge::for_generated::MessagePort,
52 that: impl CstDecode<
53 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
54 >,
55 req: impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>,
56) {
57 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
58 flutter_rust_bridge::for_generated::TaskInfo {
59 debug_name: "BindingLiquidSdk_accept_payment_proposed_fees",
60 port: Some(port_),
61 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
62 },
63 move || {
64 let api_that = that.cst_decode();
65 let api_req = req.cst_decode();
66 move |context| async move {
67 transform_result_dco::<_, _, crate::error::PaymentError>(
68 (move || async move {
69 let mut api_that_guard = None;
70 let decode_indices_ =
71 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
72 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
73 &api_that, 0, false,
74 )],
75 );
76 for i in decode_indices_ {
77 match i {
78 0 => {
79 api_that_guard =
80 Some(api_that.lockable_decode_async_ref().await)
81 }
82 _ => unreachable!(),
83 }
84 }
85 let api_that_guard = api_that_guard.unwrap();
86 let output_ok =
87 crate::bindings::BindingLiquidSdk::accept_payment_proposed_fees(
88 &*api_that_guard,
89 api_req,
90 )
91 .await?;
92 Ok(output_ok)
93 })()
94 .await,
95 )
96 }
97 },
98 )
99}
100fn wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(
101 port_: flutter_rust_bridge::for_generated::MessagePort,
102 that: impl CstDecode<
103 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
104 >,
105 listener: impl CstDecode<
106 StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>,
107 >,
108) {
109 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
110 flutter_rust_bridge::for_generated::TaskInfo {
111 debug_name: "BindingLiquidSdk_add_event_listener",
112 port: Some(port_),
113 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
114 },
115 move || {
116 let api_that = that.cst_decode();
117 let api_listener = listener.cst_decode();
118 move |context| async move {
119 transform_result_dco::<_, _, crate::error::SdkError>(
120 (move || async move {
121 let mut api_that_guard = None;
122 let decode_indices_ =
123 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
124 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
125 &api_that, 0, false,
126 )],
127 );
128 for i in decode_indices_ {
129 match i {
130 0 => {
131 api_that_guard =
132 Some(api_that.lockable_decode_async_ref().await)
133 }
134 _ => unreachable!(),
135 }
136 }
137 let api_that_guard = api_that_guard.unwrap();
138 let output_ok = crate::bindings::BindingLiquidSdk::add_event_listener(
139 &*api_that_guard,
140 api_listener,
141 )
142 .await?;
143 Ok(output_ok)
144 })()
145 .await,
146 )
147 }
148 },
149 )
150}
151fn wire__crate__bindings__BindingLiquidSdk_backup_impl(
152 that: impl CstDecode<
153 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
154 >,
155 req: impl CstDecode<crate::model::BackupRequest>,
156) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
157 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
158 flutter_rust_bridge::for_generated::TaskInfo {
159 debug_name: "BindingLiquidSdk_backup",
160 port: None,
161 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
162 },
163 move || {
164 let api_that = that.cst_decode();
165 let api_req = req.cst_decode();
166 transform_result_dco::<_, _, crate::error::SdkError>((move || {
167 let mut api_that_guard = None;
168 let decode_indices_ =
169 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
170 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
171 &api_that, 0, false,
172 ),
173 ]);
174 for i in decode_indices_ {
175 match i {
176 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
177 _ => unreachable!(),
178 }
179 }
180 let api_that_guard = api_that_guard.unwrap();
181 let output_ok =
182 crate::bindings::BindingLiquidSdk::backup(&*api_that_guard, api_req)?;
183 Ok(output_ok)
184 })())
185 },
186 )
187}
188fn wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(
189 port_: flutter_rust_bridge::for_generated::MessagePort,
190 that: impl CstDecode<
191 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
192 >,
193 req: impl CstDecode<crate::model::BuyBitcoinRequest>,
194) {
195 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
196 flutter_rust_bridge::for_generated::TaskInfo {
197 debug_name: "BindingLiquidSdk_buy_bitcoin",
198 port: Some(port_),
199 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
200 },
201 move || {
202 let api_that = that.cst_decode();
203 let api_req = req.cst_decode();
204 move |context| async move {
205 transform_result_dco::<_, _, crate::error::PaymentError>(
206 (move || async move {
207 let mut api_that_guard = None;
208 let decode_indices_ =
209 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
210 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
211 &api_that, 0, false,
212 )],
213 );
214 for i in decode_indices_ {
215 match i {
216 0 => {
217 api_that_guard =
218 Some(api_that.lockable_decode_async_ref().await)
219 }
220 _ => unreachable!(),
221 }
222 }
223 let api_that_guard = api_that_guard.unwrap();
224 let output_ok = crate::bindings::BindingLiquidSdk::buy_bitcoin(
225 &*api_that_guard,
226 api_req,
227 )
228 .await?;
229 Ok(output_ok)
230 })()
231 .await,
232 )
233 }
234 },
235 )
236}
237fn wire__crate__bindings__BindingLiquidSdk_check_message_impl(
238 that: impl CstDecode<
239 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
240 >,
241 req: impl CstDecode<crate::model::CheckMessageRequest>,
242) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
243 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
244 flutter_rust_bridge::for_generated::TaskInfo {
245 debug_name: "BindingLiquidSdk_check_message",
246 port: None,
247 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
248 },
249 move || {
250 let api_that = that.cst_decode();
251 let api_req = req.cst_decode();
252 transform_result_dco::<_, _, crate::error::SdkError>((move || {
253 let mut api_that_guard = None;
254 let decode_indices_ =
255 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
256 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
257 &api_that, 0, false,
258 ),
259 ]);
260 for i in decode_indices_ {
261 match i {
262 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
263 _ => unreachable!(),
264 }
265 }
266 let api_that_guard = api_that_guard.unwrap();
267 let output_ok =
268 crate::bindings::BindingLiquidSdk::check_message(&*api_that_guard, api_req)?;
269 Ok(output_ok)
270 })())
271 },
272 )
273}
274fn wire__crate__bindings__BindingLiquidSdk_disconnect_impl(
275 port_: flutter_rust_bridge::for_generated::MessagePort,
276 that: impl CstDecode<
277 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
278 >,
279) {
280 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
281 flutter_rust_bridge::for_generated::TaskInfo {
282 debug_name: "BindingLiquidSdk_disconnect",
283 port: Some(port_),
284 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
285 },
286 move || {
287 let api_that = that.cst_decode();
288 move |context| async move {
289 transform_result_dco::<_, _, crate::error::SdkError>(
290 (move || async move {
291 let mut api_that_guard = None;
292 let decode_indices_ =
293 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
294 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
295 &api_that, 0, false,
296 )],
297 );
298 for i in decode_indices_ {
299 match i {
300 0 => {
301 api_that_guard =
302 Some(api_that.lockable_decode_async_ref().await)
303 }
304 _ => unreachable!(),
305 }
306 }
307 let api_that_guard = api_that_guard.unwrap();
308 let output_ok =
309 crate::bindings::BindingLiquidSdk::disconnect(&*api_that_guard).await?;
310 Ok(output_ok)
311 })()
312 .await,
313 )
314 }
315 },
316 )
317}
318fn wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(
319 that: impl CstDecode<
320 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
321 >,
322) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
323 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
324 flutter_rust_bridge::for_generated::TaskInfo {
325 debug_name: "BindingLiquidSdk_empty_wallet_cache",
326 port: None,
327 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
328 },
329 move || {
330 let api_that = that.cst_decode();
331 transform_result_dco::<_, _, crate::error::SdkError>((move || {
332 let mut api_that_guard = None;
333 let decode_indices_ =
334 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
335 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
336 &api_that, 0, false,
337 ),
338 ]);
339 for i in decode_indices_ {
340 match i {
341 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
342 _ => unreachable!(),
343 }
344 }
345 let api_that_guard = api_that_guard.unwrap();
346 let output_ok =
347 crate::bindings::BindingLiquidSdk::empty_wallet_cache(&*api_that_guard)?;
348 Ok(output_ok)
349 })())
350 },
351 )
352}
353fn wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(
354 port_: flutter_rust_bridge::for_generated::MessagePort,
355 that: impl CstDecode<
356 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
357 >,
358) {
359 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
360 flutter_rust_bridge::for_generated::TaskInfo {
361 debug_name: "BindingLiquidSdk_fetch_fiat_rates",
362 port: Some(port_),
363 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
364 },
365 move || {
366 let api_that = that.cst_decode();
367 move |context| async move {
368 transform_result_dco::<_, _, crate::error::SdkError>(
369 (move || async move {
370 let mut api_that_guard = None;
371 let decode_indices_ =
372 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
373 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
374 &api_that, 0, false,
375 )],
376 );
377 for i in decode_indices_ {
378 match i {
379 0 => {
380 api_that_guard =
381 Some(api_that.lockable_decode_async_ref().await)
382 }
383 _ => unreachable!(),
384 }
385 }
386 let api_that_guard = api_that_guard.unwrap();
387 let output_ok =
388 crate::bindings::BindingLiquidSdk::fetch_fiat_rates(&*api_that_guard)
389 .await?;
390 Ok(output_ok)
391 })()
392 .await,
393 )
394 }
395 },
396 )
397}
398fn wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(
399 port_: flutter_rust_bridge::for_generated::MessagePort,
400 that: impl CstDecode<
401 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
402 >,
403) {
404 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
405 flutter_rust_bridge::for_generated::TaskInfo {
406 debug_name: "BindingLiquidSdk_fetch_lightning_limits",
407 port: Some(port_),
408 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
409 },
410 move || {
411 let api_that = that.cst_decode();
412 move |context| async move {
413 transform_result_dco::<_, _, crate::error::PaymentError>(
414 (move || async move {
415 let mut api_that_guard = None;
416 let decode_indices_ =
417 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
418 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
419 &api_that, 0, false,
420 )],
421 );
422 for i in decode_indices_ {
423 match i {
424 0 => {
425 api_that_guard =
426 Some(api_that.lockable_decode_async_ref().await)
427 }
428 _ => unreachable!(),
429 }
430 }
431 let api_that_guard = api_that_guard.unwrap();
432 let output_ok = crate::bindings::BindingLiquidSdk::fetch_lightning_limits(
433 &*api_that_guard,
434 )
435 .await?;
436 Ok(output_ok)
437 })()
438 .await,
439 )
440 }
441 },
442 )
443}
444fn wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(
445 port_: flutter_rust_bridge::for_generated::MessagePort,
446 that: impl CstDecode<
447 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
448 >,
449) {
450 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
451 flutter_rust_bridge::for_generated::TaskInfo {
452 debug_name: "BindingLiquidSdk_fetch_onchain_limits",
453 port: Some(port_),
454 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
455 },
456 move || {
457 let api_that = that.cst_decode();
458 move |context| async move {
459 transform_result_dco::<_, _, crate::error::PaymentError>(
460 (move || async move {
461 let mut api_that_guard = None;
462 let decode_indices_ =
463 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
464 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
465 &api_that, 0, false,
466 )],
467 );
468 for i in decode_indices_ {
469 match i {
470 0 => {
471 api_that_guard =
472 Some(api_that.lockable_decode_async_ref().await)
473 }
474 _ => unreachable!(),
475 }
476 }
477 let api_that_guard = api_that_guard.unwrap();
478 let output_ok = crate::bindings::BindingLiquidSdk::fetch_onchain_limits(
479 &*api_that_guard,
480 )
481 .await?;
482 Ok(output_ok)
483 })()
484 .await,
485 )
486 }
487 },
488 )
489}
490fn wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(
491 port_: flutter_rust_bridge::for_generated::MessagePort,
492 that: impl CstDecode<
493 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
494 >,
495 req: impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>,
496) {
497 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
498 flutter_rust_bridge::for_generated::TaskInfo {
499 debug_name: "BindingLiquidSdk_fetch_payment_proposed_fees",
500 port: Some(port_),
501 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
502 },
503 move || {
504 let api_that = that.cst_decode();
505 let api_req = req.cst_decode();
506 move |context| async move {
507 transform_result_dco::<_, _, crate::error::SdkError>(
508 (move || async move {
509 let mut api_that_guard = None;
510 let decode_indices_ =
511 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
512 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
513 &api_that, 0, false,
514 )],
515 );
516 for i in decode_indices_ {
517 match i {
518 0 => {
519 api_that_guard =
520 Some(api_that.lockable_decode_async_ref().await)
521 }
522 _ => unreachable!(),
523 }
524 }
525 let api_that_guard = api_that_guard.unwrap();
526 let output_ok =
527 crate::bindings::BindingLiquidSdk::fetch_payment_proposed_fees(
528 &*api_that_guard,
529 api_req,
530 )
531 .await?;
532 Ok(output_ok)
533 })()
534 .await,
535 )
536 }
537 },
538 )
539}
540fn wire__crate__bindings__BindingLiquidSdk_get_info_impl(
541 port_: flutter_rust_bridge::for_generated::MessagePort,
542 that: impl CstDecode<
543 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
544 >,
545) {
546 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
547 flutter_rust_bridge::for_generated::TaskInfo {
548 debug_name: "BindingLiquidSdk_get_info",
549 port: Some(port_),
550 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
551 },
552 move || {
553 let api_that = that.cst_decode();
554 move |context| async move {
555 transform_result_dco::<_, _, crate::error::SdkError>(
556 (move || async move {
557 let mut api_that_guard = None;
558 let decode_indices_ =
559 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
560 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
561 &api_that, 0, false,
562 )],
563 );
564 for i in decode_indices_ {
565 match i {
566 0 => {
567 api_that_guard =
568 Some(api_that.lockable_decode_async_ref().await)
569 }
570 _ => unreachable!(),
571 }
572 }
573 let api_that_guard = api_that_guard.unwrap();
574 let output_ok =
575 crate::bindings::BindingLiquidSdk::get_info(&*api_that_guard).await?;
576 Ok(output_ok)
577 })()
578 .await,
579 )
580 }
581 },
582 )
583}
584fn wire__crate__bindings__BindingLiquidSdk_get_payment_impl(
585 port_: flutter_rust_bridge::for_generated::MessagePort,
586 that: impl CstDecode<
587 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
588 >,
589 req: impl CstDecode<crate::model::GetPaymentRequest>,
590) {
591 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
592 flutter_rust_bridge::for_generated::TaskInfo {
593 debug_name: "BindingLiquidSdk_get_payment",
594 port: Some(port_),
595 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
596 },
597 move || {
598 let api_that = that.cst_decode();
599 let api_req = req.cst_decode();
600 move |context| async move {
601 transform_result_dco::<_, _, crate::error::PaymentError>(
602 (move || async move {
603 let mut api_that_guard = None;
604 let decode_indices_ =
605 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
606 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
607 &api_that, 0, false,
608 )],
609 );
610 for i in decode_indices_ {
611 match i {
612 0 => {
613 api_that_guard =
614 Some(api_that.lockable_decode_async_ref().await)
615 }
616 _ => unreachable!(),
617 }
618 }
619 let api_that_guard = api_that_guard.unwrap();
620 let output_ok = crate::bindings::BindingLiquidSdk::get_payment(
621 &*api_that_guard,
622 api_req,
623 )
624 .await?;
625 Ok(output_ok)
626 })()
627 .await,
628 )
629 }
630 },
631 )
632}
633fn wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(
634 port_: flutter_rust_bridge::for_generated::MessagePort,
635 that: impl CstDecode<
636 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
637 >,
638) {
639 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
640 flutter_rust_bridge::for_generated::TaskInfo {
641 debug_name: "BindingLiquidSdk_list_fiat_currencies",
642 port: Some(port_),
643 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
644 },
645 move || {
646 let api_that = that.cst_decode();
647 move |context| async move {
648 transform_result_dco::<_, _, crate::error::SdkError>(
649 (move || async move {
650 let mut api_that_guard = None;
651 let decode_indices_ =
652 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
653 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
654 &api_that, 0, false,
655 )],
656 );
657 for i in decode_indices_ {
658 match i {
659 0 => {
660 api_that_guard =
661 Some(api_that.lockable_decode_async_ref().await)
662 }
663 _ => unreachable!(),
664 }
665 }
666 let api_that_guard = api_that_guard.unwrap();
667 let output_ok = crate::bindings::BindingLiquidSdk::list_fiat_currencies(
668 &*api_that_guard,
669 )
670 .await?;
671 Ok(output_ok)
672 })()
673 .await,
674 )
675 }
676 },
677 )
678}
679fn wire__crate__bindings__BindingLiquidSdk_list_payments_impl(
680 port_: flutter_rust_bridge::for_generated::MessagePort,
681 that: impl CstDecode<
682 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
683 >,
684 req: impl CstDecode<crate::model::ListPaymentsRequest>,
685) {
686 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
687 flutter_rust_bridge::for_generated::TaskInfo {
688 debug_name: "BindingLiquidSdk_list_payments",
689 port: Some(port_),
690 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
691 },
692 move || {
693 let api_that = that.cst_decode();
694 let api_req = req.cst_decode();
695 move |context| async move {
696 transform_result_dco::<_, _, crate::error::PaymentError>(
697 (move || async move {
698 let mut api_that_guard = None;
699 let decode_indices_ =
700 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
701 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
702 &api_that, 0, false,
703 )],
704 );
705 for i in decode_indices_ {
706 match i {
707 0 => {
708 api_that_guard =
709 Some(api_that.lockable_decode_async_ref().await)
710 }
711 _ => unreachable!(),
712 }
713 }
714 let api_that_guard = api_that_guard.unwrap();
715 let output_ok = crate::bindings::BindingLiquidSdk::list_payments(
716 &*api_that_guard,
717 api_req,
718 )
719 .await?;
720 Ok(output_ok)
721 })()
722 .await,
723 )
724 }
725 },
726 )
727}
728fn wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(
729 port_: flutter_rust_bridge::for_generated::MessagePort,
730 that: impl CstDecode<
731 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
732 >,
733) {
734 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
735 flutter_rust_bridge::for_generated::TaskInfo {
736 debug_name: "BindingLiquidSdk_list_refundables",
737 port: Some(port_),
738 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
739 },
740 move || {
741 let api_that = that.cst_decode();
742 move |context| async move {
743 transform_result_dco::<_, _, crate::error::SdkError>(
744 (move || async move {
745 let mut api_that_guard = None;
746 let decode_indices_ =
747 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
748 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
749 &api_that, 0, false,
750 )],
751 );
752 for i in decode_indices_ {
753 match i {
754 0 => {
755 api_that_guard =
756 Some(api_that.lockable_decode_async_ref().await)
757 }
758 _ => unreachable!(),
759 }
760 }
761 let api_that_guard = api_that_guard.unwrap();
762 let output_ok =
763 crate::bindings::BindingLiquidSdk::list_refundables(&*api_that_guard)
764 .await?;
765 Ok(output_ok)
766 })()
767 .await,
768 )
769 }
770 },
771 )
772}
773fn wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(
774 port_: flutter_rust_bridge::for_generated::MessagePort,
775 that: impl CstDecode<
776 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
777 >,
778 req_data: impl CstDecode<crate::bindings::LnUrlAuthRequestData>,
779) {
780 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
781 flutter_rust_bridge::for_generated::TaskInfo {
782 debug_name: "BindingLiquidSdk_lnurl_auth",
783 port: Some(port_),
784 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
785 },
786 move || {
787 let api_that = that.cst_decode();
788 let api_req_data = req_data.cst_decode();
789 move |context| async move {
790 transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlAuthError>(
791 (move || async move {
792 let mut api_that_guard = None;
793 let decode_indices_ =
794 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
795 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
796 &api_that, 0, false,
797 )],
798 );
799 for i in decode_indices_ {
800 match i {
801 0 => {
802 api_that_guard =
803 Some(api_that.lockable_decode_async_ref().await)
804 }
805 _ => unreachable!(),
806 }
807 }
808 let api_that_guard = api_that_guard.unwrap();
809 let output_ok = crate::bindings::BindingLiquidSdk::lnurl_auth(
810 &*api_that_guard,
811 api_req_data,
812 )
813 .await?;
814 Ok(output_ok)
815 })()
816 .await,
817 )
818 }
819 },
820 )
821}
822fn wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(
823 port_: flutter_rust_bridge::for_generated::MessagePort,
824 that: impl CstDecode<
825 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
826 >,
827 req: impl CstDecode<crate::model::LnUrlPayRequest>,
828) {
829 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
830 flutter_rust_bridge::for_generated::TaskInfo {
831 debug_name: "BindingLiquidSdk_lnurl_pay",
832 port: Some(port_),
833 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
834 },
835 move || {
836 let api_that = that.cst_decode();
837 let api_req = req.cst_decode();
838 move |context| async move {
839 transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlPayError>(
840 (move || async move {
841 let mut api_that_guard = None;
842 let decode_indices_ =
843 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
844 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
845 &api_that, 0, false,
846 )],
847 );
848 for i in decode_indices_ {
849 match i {
850 0 => {
851 api_that_guard =
852 Some(api_that.lockable_decode_async_ref().await)
853 }
854 _ => unreachable!(),
855 }
856 }
857 let api_that_guard = api_that_guard.unwrap();
858 let output_ok =
859 crate::bindings::BindingLiquidSdk::lnurl_pay(&*api_that_guard, api_req)
860 .await?;
861 Ok(output_ok)
862 })()
863 .await,
864 )
865 }
866 },
867 )
868}
869fn wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(
870 port_: flutter_rust_bridge::for_generated::MessagePort,
871 that: impl CstDecode<
872 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
873 >,
874 req: impl CstDecode<crate::bindings::LnUrlWithdrawRequest>,
875) {
876 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
877 flutter_rust_bridge::for_generated::TaskInfo {
878 debug_name: "BindingLiquidSdk_lnurl_withdraw",
879 port: Some(port_),
880 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
881 },
882 move || {
883 let api_that = that.cst_decode();
884 let api_req = req.cst_decode();
885 move |context| async move {
886 transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlWithdrawError>(
887 (move || async move {
888 let mut api_that_guard = None;
889 let decode_indices_ =
890 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
891 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
892 &api_that, 0, false,
893 )],
894 );
895 for i in decode_indices_ {
896 match i {
897 0 => {
898 api_that_guard =
899 Some(api_that.lockable_decode_async_ref().await)
900 }
901 _ => unreachable!(),
902 }
903 }
904 let api_that_guard = api_that_guard.unwrap();
905 let output_ok = crate::bindings::BindingLiquidSdk::lnurl_withdraw(
906 &*api_that_guard,
907 api_req,
908 )
909 .await?;
910 Ok(output_ok)
911 })()
912 .await,
913 )
914 }
915 },
916 )
917}
918fn wire__crate__bindings__BindingLiquidSdk_parse_impl(
919 port_: flutter_rust_bridge::for_generated::MessagePort,
920 that: impl CstDecode<
921 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
922 >,
923 input: impl CstDecode<String>,
924) {
925 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
926 flutter_rust_bridge::for_generated::TaskInfo {
927 debug_name: "BindingLiquidSdk_parse",
928 port: Some(port_),
929 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
930 },
931 move || {
932 let api_that = that.cst_decode();
933 let api_input = input.cst_decode();
934 move |context| async move {
935 transform_result_dco::<_, _, crate::error::PaymentError>(
936 (move || async move {
937 let mut api_that_guard = None;
938 let decode_indices_ =
939 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
940 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
941 &api_that, 0, false,
942 )],
943 );
944 for i in decode_indices_ {
945 match i {
946 0 => {
947 api_that_guard =
948 Some(api_that.lockable_decode_async_ref().await)
949 }
950 _ => unreachable!(),
951 }
952 }
953 let api_that_guard = api_that_guard.unwrap();
954 let output_ok =
955 crate::bindings::BindingLiquidSdk::parse(&*api_that_guard, api_input)
956 .await?;
957 Ok(output_ok)
958 })()
959 .await,
960 )
961 }
962 },
963 )
964}
965fn wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(
966 port_: flutter_rust_bridge::for_generated::MessagePort,
967 that: impl CstDecode<
968 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
969 >,
970 req: impl CstDecode<crate::model::PayOnchainRequest>,
971) {
972 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
973 flutter_rust_bridge::for_generated::TaskInfo {
974 debug_name: "BindingLiquidSdk_pay_onchain",
975 port: Some(port_),
976 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
977 },
978 move || {
979 let api_that = that.cst_decode();
980 let api_req = req.cst_decode();
981 move |context| async move {
982 transform_result_dco::<_, _, crate::error::PaymentError>(
983 (move || async move {
984 let mut api_that_guard = None;
985 let decode_indices_ =
986 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
987 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
988 &api_that, 0, false,
989 )],
990 );
991 for i in decode_indices_ {
992 match i {
993 0 => {
994 api_that_guard =
995 Some(api_that.lockable_decode_async_ref().await)
996 }
997 _ => unreachable!(),
998 }
999 }
1000 let api_that_guard = api_that_guard.unwrap();
1001 let output_ok = crate::bindings::BindingLiquidSdk::pay_onchain(
1002 &*api_that_guard,
1003 api_req,
1004 )
1005 .await?;
1006 Ok(output_ok)
1007 })()
1008 .await,
1009 )
1010 }
1011 },
1012 )
1013}
1014fn wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(
1015 port_: flutter_rust_bridge::for_generated::MessagePort,
1016 that: impl CstDecode<
1017 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1018 >,
1019 req: impl CstDecode<crate::model::PrepareBuyBitcoinRequest>,
1020) {
1021 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1022 flutter_rust_bridge::for_generated::TaskInfo {
1023 debug_name: "BindingLiquidSdk_prepare_buy_bitcoin",
1024 port: Some(port_),
1025 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1026 },
1027 move || {
1028 let api_that = that.cst_decode();
1029 let api_req = req.cst_decode();
1030 move |context| async move {
1031 transform_result_dco::<_, _, crate::error::PaymentError>(
1032 (move || async move {
1033 let mut api_that_guard = None;
1034 let decode_indices_ =
1035 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1036 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1037 &api_that, 0, false,
1038 )],
1039 );
1040 for i in decode_indices_ {
1041 match i {
1042 0 => {
1043 api_that_guard =
1044 Some(api_that.lockable_decode_async_ref().await)
1045 }
1046 _ => unreachable!(),
1047 }
1048 }
1049 let api_that_guard = api_that_guard.unwrap();
1050 let output_ok = crate::bindings::BindingLiquidSdk::prepare_buy_bitcoin(
1051 &*api_that_guard,
1052 api_req,
1053 )
1054 .await?;
1055 Ok(output_ok)
1056 })()
1057 .await,
1058 )
1059 }
1060 },
1061 )
1062}
1063fn wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(
1064 port_: flutter_rust_bridge::for_generated::MessagePort,
1065 that: impl CstDecode<
1066 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1067 >,
1068 req: impl CstDecode<crate::model::PrepareLnUrlPayRequest>,
1069) {
1070 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1071 flutter_rust_bridge::for_generated::TaskInfo {
1072 debug_name: "BindingLiquidSdk_prepare_lnurl_pay",
1073 port: Some(port_),
1074 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1075 },
1076 move || {
1077 let api_that = that.cst_decode();
1078 let api_req = req.cst_decode();
1079 move |context| async move {
1080 transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlPayError>(
1081 (move || async move {
1082 let mut api_that_guard = None;
1083 let decode_indices_ =
1084 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1085 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1086 &api_that, 0, false,
1087 )],
1088 );
1089 for i in decode_indices_ {
1090 match i {
1091 0 => {
1092 api_that_guard =
1093 Some(api_that.lockable_decode_async_ref().await)
1094 }
1095 _ => unreachable!(),
1096 }
1097 }
1098 let api_that_guard = api_that_guard.unwrap();
1099 let output_ok = crate::bindings::BindingLiquidSdk::prepare_lnurl_pay(
1100 &*api_that_guard,
1101 api_req,
1102 )
1103 .await?;
1104 Ok(output_ok)
1105 })()
1106 .await,
1107 )
1108 }
1109 },
1110 )
1111}
1112fn wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(
1113 port_: flutter_rust_bridge::for_generated::MessagePort,
1114 that: impl CstDecode<
1115 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1116 >,
1117 req: impl CstDecode<crate::model::PreparePayOnchainRequest>,
1118) {
1119 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1120 flutter_rust_bridge::for_generated::TaskInfo {
1121 debug_name: "BindingLiquidSdk_prepare_pay_onchain",
1122 port: Some(port_),
1123 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1124 },
1125 move || {
1126 let api_that = that.cst_decode();
1127 let api_req = req.cst_decode();
1128 move |context| async move {
1129 transform_result_dco::<_, _, crate::error::PaymentError>(
1130 (move || async move {
1131 let mut api_that_guard = None;
1132 let decode_indices_ =
1133 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1134 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1135 &api_that, 0, false,
1136 )],
1137 );
1138 for i in decode_indices_ {
1139 match i {
1140 0 => {
1141 api_that_guard =
1142 Some(api_that.lockable_decode_async_ref().await)
1143 }
1144 _ => unreachable!(),
1145 }
1146 }
1147 let api_that_guard = api_that_guard.unwrap();
1148 let output_ok = crate::bindings::BindingLiquidSdk::prepare_pay_onchain(
1149 &*api_that_guard,
1150 api_req,
1151 )
1152 .await?;
1153 Ok(output_ok)
1154 })()
1155 .await,
1156 )
1157 }
1158 },
1159 )
1160}
1161fn wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(
1162 port_: flutter_rust_bridge::for_generated::MessagePort,
1163 that: impl CstDecode<
1164 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1165 >,
1166 req: impl CstDecode<crate::model::PrepareReceiveRequest>,
1167) {
1168 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1169 flutter_rust_bridge::for_generated::TaskInfo {
1170 debug_name: "BindingLiquidSdk_prepare_receive_payment",
1171 port: Some(port_),
1172 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1173 },
1174 move || {
1175 let api_that = that.cst_decode();
1176 let api_req = req.cst_decode();
1177 move |context| async move {
1178 transform_result_dco::<_, _, crate::error::PaymentError>(
1179 (move || async move {
1180 let mut api_that_guard = None;
1181 let decode_indices_ =
1182 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1183 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1184 &api_that, 0, false,
1185 )],
1186 );
1187 for i in decode_indices_ {
1188 match i {
1189 0 => {
1190 api_that_guard =
1191 Some(api_that.lockable_decode_async_ref().await)
1192 }
1193 _ => unreachable!(),
1194 }
1195 }
1196 let api_that_guard = api_that_guard.unwrap();
1197 let output_ok = crate::bindings::BindingLiquidSdk::prepare_receive_payment(
1198 &*api_that_guard,
1199 api_req,
1200 )
1201 .await?;
1202 Ok(output_ok)
1203 })()
1204 .await,
1205 )
1206 }
1207 },
1208 )
1209}
1210fn wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(
1211 port_: flutter_rust_bridge::for_generated::MessagePort,
1212 that: impl CstDecode<
1213 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1214 >,
1215 req: impl CstDecode<crate::model::PrepareRefundRequest>,
1216) {
1217 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1218 flutter_rust_bridge::for_generated::TaskInfo {
1219 debug_name: "BindingLiquidSdk_prepare_refund",
1220 port: Some(port_),
1221 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1222 },
1223 move || {
1224 let api_that = that.cst_decode();
1225 let api_req = req.cst_decode();
1226 move |context| async move {
1227 transform_result_dco::<_, _, crate::error::SdkError>(
1228 (move || async move {
1229 let mut api_that_guard = None;
1230 let decode_indices_ =
1231 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1232 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1233 &api_that, 0, false,
1234 )],
1235 );
1236 for i in decode_indices_ {
1237 match i {
1238 0 => {
1239 api_that_guard =
1240 Some(api_that.lockable_decode_async_ref().await)
1241 }
1242 _ => unreachable!(),
1243 }
1244 }
1245 let api_that_guard = api_that_guard.unwrap();
1246 let output_ok = crate::bindings::BindingLiquidSdk::prepare_refund(
1247 &*api_that_guard,
1248 api_req,
1249 )
1250 .await?;
1251 Ok(output_ok)
1252 })()
1253 .await,
1254 )
1255 }
1256 },
1257 )
1258}
1259fn wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(
1260 port_: flutter_rust_bridge::for_generated::MessagePort,
1261 that: impl CstDecode<
1262 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1263 >,
1264 req: impl CstDecode<crate::model::PrepareSendRequest>,
1265) {
1266 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1267 flutter_rust_bridge::for_generated::TaskInfo {
1268 debug_name: "BindingLiquidSdk_prepare_send_payment",
1269 port: Some(port_),
1270 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1271 },
1272 move || {
1273 let api_that = that.cst_decode();
1274 let api_req = req.cst_decode();
1275 move |context| async move {
1276 transform_result_dco::<_, _, crate::error::PaymentError>(
1277 (move || async move {
1278 let mut api_that_guard = None;
1279 let decode_indices_ =
1280 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1281 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1282 &api_that, 0, false,
1283 )],
1284 );
1285 for i in decode_indices_ {
1286 match i {
1287 0 => {
1288 api_that_guard =
1289 Some(api_that.lockable_decode_async_ref().await)
1290 }
1291 _ => unreachable!(),
1292 }
1293 }
1294 let api_that_guard = api_that_guard.unwrap();
1295 let output_ok = crate::bindings::BindingLiquidSdk::prepare_send_payment(
1296 &*api_that_guard,
1297 api_req,
1298 )
1299 .await?;
1300 Ok(output_ok)
1301 })()
1302 .await,
1303 )
1304 }
1305 },
1306 )
1307}
1308fn wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(
1309 port_: flutter_rust_bridge::for_generated::MessagePort,
1310 that: impl CstDecode<
1311 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1312 >,
1313 req: impl CstDecode<crate::model::ReceivePaymentRequest>,
1314) {
1315 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1316 flutter_rust_bridge::for_generated::TaskInfo {
1317 debug_name: "BindingLiquidSdk_receive_payment",
1318 port: Some(port_),
1319 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1320 },
1321 move || {
1322 let api_that = that.cst_decode();
1323 let api_req = req.cst_decode();
1324 move |context| async move {
1325 transform_result_dco::<_, _, crate::error::PaymentError>(
1326 (move || async move {
1327 let mut api_that_guard = None;
1328 let decode_indices_ =
1329 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1330 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1331 &api_that, 0, false,
1332 )],
1333 );
1334 for i in decode_indices_ {
1335 match i {
1336 0 => {
1337 api_that_guard =
1338 Some(api_that.lockable_decode_async_ref().await)
1339 }
1340 _ => unreachable!(),
1341 }
1342 }
1343 let api_that_guard = api_that_guard.unwrap();
1344 let output_ok = crate::bindings::BindingLiquidSdk::receive_payment(
1345 &*api_that_guard,
1346 api_req,
1347 )
1348 .await?;
1349 Ok(output_ok)
1350 })()
1351 .await,
1352 )
1353 }
1354 },
1355 )
1356}
1357fn wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(
1358 port_: flutter_rust_bridge::for_generated::MessagePort,
1359 that: impl CstDecode<
1360 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1361 >,
1362) {
1363 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1364 flutter_rust_bridge::for_generated::TaskInfo {
1365 debug_name: "BindingLiquidSdk_recommended_fees",
1366 port: Some(port_),
1367 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1368 },
1369 move || {
1370 let api_that = that.cst_decode();
1371 move |context| async move {
1372 transform_result_dco::<_, _, crate::error::SdkError>(
1373 (move || async move {
1374 let mut api_that_guard = None;
1375 let decode_indices_ =
1376 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1377 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1378 &api_that, 0, false,
1379 )],
1380 );
1381 for i in decode_indices_ {
1382 match i {
1383 0 => {
1384 api_that_guard =
1385 Some(api_that.lockable_decode_async_ref().await)
1386 }
1387 _ => unreachable!(),
1388 }
1389 }
1390 let api_that_guard = api_that_guard.unwrap();
1391 let output_ok =
1392 crate::bindings::BindingLiquidSdk::recommended_fees(&*api_that_guard)
1393 .await?;
1394 Ok(output_ok)
1395 })()
1396 .await,
1397 )
1398 }
1399 },
1400 )
1401}
1402fn wire__crate__bindings__BindingLiquidSdk_refund_impl(
1403 port_: flutter_rust_bridge::for_generated::MessagePort,
1404 that: impl CstDecode<
1405 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1406 >,
1407 req: impl CstDecode<crate::model::RefundRequest>,
1408) {
1409 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1410 flutter_rust_bridge::for_generated::TaskInfo {
1411 debug_name: "BindingLiquidSdk_refund",
1412 port: Some(port_),
1413 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1414 },
1415 move || {
1416 let api_that = that.cst_decode();
1417 let api_req = req.cst_decode();
1418 move |context| async move {
1419 transform_result_dco::<_, _, crate::error::PaymentError>(
1420 (move || async move {
1421 let mut api_that_guard = None;
1422 let decode_indices_ =
1423 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1424 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1425 &api_that, 0, false,
1426 )],
1427 );
1428 for i in decode_indices_ {
1429 match i {
1430 0 => {
1431 api_that_guard =
1432 Some(api_that.lockable_decode_async_ref().await)
1433 }
1434 _ => unreachable!(),
1435 }
1436 }
1437 let api_that_guard = api_that_guard.unwrap();
1438 let output_ok =
1439 crate::bindings::BindingLiquidSdk::refund(&*api_that_guard, api_req)
1440 .await?;
1441 Ok(output_ok)
1442 })()
1443 .await,
1444 )
1445 }
1446 },
1447 )
1448}
1449fn wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(
1450 port_: flutter_rust_bridge::for_generated::MessagePort,
1451 that: impl CstDecode<
1452 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1453 >,
1454 webhook_url: impl CstDecode<String>,
1455) {
1456 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1457 flutter_rust_bridge::for_generated::TaskInfo {
1458 debug_name: "BindingLiquidSdk_register_webhook",
1459 port: Some(port_),
1460 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1461 },
1462 move || {
1463 let api_that = that.cst_decode();
1464 let api_webhook_url = webhook_url.cst_decode();
1465 move |context| async move {
1466 transform_result_dco::<_, _, crate::error::SdkError>(
1467 (move || async move {
1468 let mut api_that_guard = None;
1469 let decode_indices_ =
1470 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1471 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1472 &api_that, 0, false,
1473 )],
1474 );
1475 for i in decode_indices_ {
1476 match i {
1477 0 => {
1478 api_that_guard =
1479 Some(api_that.lockable_decode_async_ref().await)
1480 }
1481 _ => unreachable!(),
1482 }
1483 }
1484 let api_that_guard = api_that_guard.unwrap();
1485 let output_ok = crate::bindings::BindingLiquidSdk::register_webhook(
1486 &*api_that_guard,
1487 api_webhook_url,
1488 )
1489 .await?;
1490 Ok(output_ok)
1491 })()
1492 .await,
1493 )
1494 }
1495 },
1496 )
1497}
1498fn wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(
1499 port_: flutter_rust_bridge::for_generated::MessagePort,
1500 that: impl CstDecode<
1501 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1502 >,
1503) {
1504 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1505 flutter_rust_bridge::for_generated::TaskInfo {
1506 debug_name: "BindingLiquidSdk_rescan_onchain_swaps",
1507 port: Some(port_),
1508 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1509 },
1510 move || {
1511 let api_that = that.cst_decode();
1512 move |context| async move {
1513 transform_result_dco::<_, _, crate::error::SdkError>(
1514 (move || async move {
1515 let mut api_that_guard = None;
1516 let decode_indices_ =
1517 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1518 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1519 &api_that, 0, false,
1520 )],
1521 );
1522 for i in decode_indices_ {
1523 match i {
1524 0 => {
1525 api_that_guard =
1526 Some(api_that.lockable_decode_async_ref().await)
1527 }
1528 _ => unreachable!(),
1529 }
1530 }
1531 let api_that_guard = api_that_guard.unwrap();
1532 let output_ok = crate::bindings::BindingLiquidSdk::rescan_onchain_swaps(
1533 &*api_that_guard,
1534 )
1535 .await?;
1536 Ok(output_ok)
1537 })()
1538 .await,
1539 )
1540 }
1541 },
1542 )
1543}
1544fn wire__crate__bindings__BindingLiquidSdk_restore_impl(
1545 that: impl CstDecode<
1546 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1547 >,
1548 req: impl CstDecode<crate::model::RestoreRequest>,
1549) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1550 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1551 flutter_rust_bridge::for_generated::TaskInfo {
1552 debug_name: "BindingLiquidSdk_restore",
1553 port: None,
1554 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1555 },
1556 move || {
1557 let api_that = that.cst_decode();
1558 let api_req = req.cst_decode();
1559 transform_result_dco::<_, _, crate::error::SdkError>((move || {
1560 let mut api_that_guard = None;
1561 let decode_indices_ =
1562 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
1563 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1564 &api_that, 0, false,
1565 ),
1566 ]);
1567 for i in decode_indices_ {
1568 match i {
1569 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
1570 _ => unreachable!(),
1571 }
1572 }
1573 let api_that_guard = api_that_guard.unwrap();
1574 let output_ok =
1575 crate::bindings::BindingLiquidSdk::restore(&*api_that_guard, api_req)?;
1576 Ok(output_ok)
1577 })())
1578 },
1579 )
1580}
1581fn wire__crate__bindings__BindingLiquidSdk_send_payment_impl(
1582 port_: flutter_rust_bridge::for_generated::MessagePort,
1583 that: impl CstDecode<
1584 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1585 >,
1586 req: impl CstDecode<crate::model::SendPaymentRequest>,
1587) {
1588 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1589 flutter_rust_bridge::for_generated::TaskInfo {
1590 debug_name: "BindingLiquidSdk_send_payment",
1591 port: Some(port_),
1592 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1593 },
1594 move || {
1595 let api_that = that.cst_decode();
1596 let api_req = req.cst_decode();
1597 move |context| async move {
1598 transform_result_dco::<_, _, crate::error::PaymentError>(
1599 (move || async move {
1600 let mut api_that_guard = None;
1601 let decode_indices_ =
1602 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1603 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1604 &api_that, 0, false,
1605 )],
1606 );
1607 for i in decode_indices_ {
1608 match i {
1609 0 => {
1610 api_that_guard =
1611 Some(api_that.lockable_decode_async_ref().await)
1612 }
1613 _ => unreachable!(),
1614 }
1615 }
1616 let api_that_guard = api_that_guard.unwrap();
1617 let output_ok = crate::bindings::BindingLiquidSdk::send_payment(
1618 &*api_that_guard,
1619 api_req,
1620 )
1621 .await?;
1622 Ok(output_ok)
1623 })()
1624 .await,
1625 )
1626 }
1627 },
1628 )
1629}
1630fn wire__crate__bindings__BindingLiquidSdk_sign_message_impl(
1631 that: impl CstDecode<
1632 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1633 >,
1634 req: impl CstDecode<crate::model::SignMessageRequest>,
1635) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1636 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1637 flutter_rust_bridge::for_generated::TaskInfo {
1638 debug_name: "BindingLiquidSdk_sign_message",
1639 port: None,
1640 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1641 },
1642 move || {
1643 let api_that = that.cst_decode();
1644 let api_req = req.cst_decode();
1645 transform_result_dco::<_, _, crate::error::SdkError>((move || {
1646 let mut api_that_guard = None;
1647 let decode_indices_ =
1648 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
1649 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1650 &api_that, 0, false,
1651 ),
1652 ]);
1653 for i in decode_indices_ {
1654 match i {
1655 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
1656 _ => unreachable!(),
1657 }
1658 }
1659 let api_that_guard = api_that_guard.unwrap();
1660 let output_ok =
1661 crate::bindings::BindingLiquidSdk::sign_message(&*api_that_guard, api_req)?;
1662 Ok(output_ok)
1663 })())
1664 },
1665 )
1666}
1667fn wire__crate__bindings__BindingLiquidSdk_sync_impl(
1668 port_: flutter_rust_bridge::for_generated::MessagePort,
1669 that: impl CstDecode<
1670 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1671 >,
1672) {
1673 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1674 flutter_rust_bridge::for_generated::TaskInfo {
1675 debug_name: "BindingLiquidSdk_sync(dart_style=sync)",
1676 port: Some(port_),
1677 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1678 },
1679 move || {
1680 let api_that = that.cst_decode();
1681 move |context| async move {
1682 transform_result_dco::<_, _, crate::error::SdkError>(
1683 (move || async move {
1684 let mut api_that_guard = None;
1685 let decode_indices_ =
1686 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1687 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1688 &api_that, 0, false,
1689 )],
1690 );
1691 for i in decode_indices_ {
1692 match i {
1693 0 => {
1694 api_that_guard =
1695 Some(api_that.lockable_decode_async_ref().await)
1696 }
1697 _ => unreachable!(),
1698 }
1699 }
1700 let api_that_guard = api_that_guard.unwrap();
1701 let output_ok =
1702 crate::bindings::BindingLiquidSdk::sync(&*api_that_guard).await?;
1703 Ok(output_ok)
1704 })()
1705 .await,
1706 )
1707 }
1708 },
1709 )
1710}
1711fn wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(
1712 port_: flutter_rust_bridge::for_generated::MessagePort,
1713 that: impl CstDecode<
1714 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1715 >,
1716) {
1717 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1718 flutter_rust_bridge::for_generated::TaskInfo {
1719 debug_name: "BindingLiquidSdk_unregister_webhook",
1720 port: Some(port_),
1721 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1722 },
1723 move || {
1724 let api_that = that.cst_decode();
1725 move |context| async move {
1726 transform_result_dco::<_, _, crate::error::SdkError>(
1727 (move || async move {
1728 let mut api_that_guard = None;
1729 let decode_indices_ =
1730 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1731 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1732 &api_that, 0, false,
1733 )],
1734 );
1735 for i in decode_indices_ {
1736 match i {
1737 0 => {
1738 api_that_guard =
1739 Some(api_that.lockable_decode_async_ref().await)
1740 }
1741 _ => unreachable!(),
1742 }
1743 }
1744 let api_that_guard = api_that_guard.unwrap();
1745 let output_ok =
1746 crate::bindings::BindingLiquidSdk::unregister_webhook(&*api_that_guard)
1747 .await?;
1748 Ok(output_ok)
1749 })()
1750 .await,
1751 )
1752 }
1753 },
1754 )
1755}
1756fn wire__crate__bindings__binding_event_listener_on_event_impl(
1757 port_: flutter_rust_bridge::for_generated::MessagePort,
1758 that: impl CstDecode<crate::bindings::BindingEventListener>,
1759 e: impl CstDecode<crate::model::SdkEvent>,
1760) {
1761 FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
1762 flutter_rust_bridge::for_generated::TaskInfo {
1763 debug_name: "binding_event_listener_on_event",
1764 port: Some(port_),
1765 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1766 },
1767 move || {
1768 let api_that = that.cst_decode();
1769 let api_e = e.cst_decode();
1770 move |context| {
1771 transform_result_dco::<_, _, ()>((move || {
1772 let output_ok = Result::<_, ()>::Ok({
1773 crate::bindings::BindingEventListener::on_event(&api_that, api_e);
1774 })?;
1775 Ok(output_ok)
1776 })())
1777 }
1778 },
1779 )
1780}
1781fn wire__crate__bindings__breez_log_stream_impl(
1782 port_: flutter_rust_bridge::for_generated::MessagePort,
1783 s: impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>,
1784) {
1785 FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
1786 flutter_rust_bridge::for_generated::TaskInfo {
1787 debug_name: "breez_log_stream",
1788 port: Some(port_),
1789 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1790 },
1791 move || {
1792 let api_s = s.cst_decode();
1793 move |context| {
1794 transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
1795 (move || {
1796 let output_ok = crate::bindings::breez_log_stream(api_s)?;
1797 Ok(output_ok)
1798 })(),
1799 )
1800 }
1801 },
1802 )
1803}
1804fn wire__crate__bindings__connect_impl(
1805 port_: flutter_rust_bridge::for_generated::MessagePort,
1806 req: impl CstDecode<crate::model::ConnectRequest>,
1807) {
1808 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1809 flutter_rust_bridge::for_generated::TaskInfo {
1810 debug_name: "connect",
1811 port: Some(port_),
1812 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1813 },
1814 move || {
1815 let api_req = req.cst_decode();
1816 move |context| async move {
1817 transform_result_dco::<_, _, crate::error::SdkError>(
1818 (move || async move {
1819 let output_ok = crate::bindings::connect(api_req).await?;
1820 Ok(output_ok)
1821 })()
1822 .await,
1823 )
1824 }
1825 },
1826 )
1827}
1828fn wire__crate__bindings__default_config_impl(
1829 network: impl CstDecode<crate::model::LiquidNetwork>,
1830 breez_api_key: impl CstDecode<Option<String>>,
1831) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1832 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1833 flutter_rust_bridge::for_generated::TaskInfo {
1834 debug_name: "default_config",
1835 port: None,
1836 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1837 },
1838 move || {
1839 let api_network = network.cst_decode();
1840 let api_breez_api_key = breez_api_key.cst_decode();
1841 transform_result_dco::<_, _, crate::error::SdkError>((move || {
1842 let output_ok = crate::bindings::default_config(api_network, api_breez_api_key)?;
1843 Ok(output_ok)
1844 })())
1845 },
1846 )
1847}
1848fn wire__crate__bindings__parse_invoice_impl(
1849 input: impl CstDecode<String>,
1850) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1851 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1852 flutter_rust_bridge::for_generated::TaskInfo {
1853 debug_name: "parse_invoice",
1854 port: None,
1855 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1856 },
1857 move || {
1858 let api_input = input.cst_decode();
1859 transform_result_dco::<_, _, crate::error::PaymentError>((move || {
1860 let output_ok = crate::bindings::parse_invoice(api_input)?;
1861 Ok(output_ok)
1862 })())
1863 },
1864 )
1865}
1866
1867#[allow(clippy::unnecessary_literal_unwrap)]
1870const _: fn() = || {
1871 {
1872 let AesSuccessActionData = None::<crate::bindings::AesSuccessActionData>.unwrap();
1873 let _: String = AesSuccessActionData.description;
1874 let _: String = AesSuccessActionData.ciphertext;
1875 let _: String = AesSuccessActionData.iv;
1876 }
1877 {
1878 let AesSuccessActionDataDecrypted =
1879 None::<crate::bindings::AesSuccessActionDataDecrypted>.unwrap();
1880 let _: String = AesSuccessActionDataDecrypted.description;
1881 let _: String = AesSuccessActionDataDecrypted.plaintext;
1882 }
1883 match None::<crate::bindings::AesSuccessActionDataResult>.unwrap() {
1884 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
1885 let _: crate::bindings::AesSuccessActionDataDecrypted = data;
1886 }
1887 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
1888 let _: String = reason;
1889 }
1890 }
1891 match None::<crate::bindings::Amount>.unwrap() {
1892 crate::bindings::Amount::Bitcoin { amount_msat } => {
1893 let _: u64 = amount_msat;
1894 }
1895 crate::bindings::Amount::Currency {
1896 iso4217_code,
1897 fractional_amount,
1898 } => {
1899 let _: String = iso4217_code;
1900 let _: u64 = fractional_amount;
1901 }
1902 }
1903 {
1904 let BitcoinAddressData = None::<crate::bindings::BitcoinAddressData>.unwrap();
1905 let _: String = BitcoinAddressData.address;
1906 let _: crate::bindings::Network = BitcoinAddressData.network;
1907 let _: Option<u64> = BitcoinAddressData.amount_sat;
1908 let _: Option<String> = BitcoinAddressData.label;
1909 let _: Option<String> = BitcoinAddressData.message;
1910 }
1911 {
1912 let CurrencyInfo = None::<crate::bindings::CurrencyInfo>.unwrap();
1913 let _: String = CurrencyInfo.name;
1914 let _: u32 = CurrencyInfo.fraction_size;
1915 let _: Option<u32> = CurrencyInfo.spacing;
1916 let _: Option<crate::bindings::Symbol> = CurrencyInfo.symbol;
1917 let _: Option<crate::bindings::Symbol> = CurrencyInfo.uniq_symbol;
1918 let _: Vec<crate::bindings::LocalizedName> = CurrencyInfo.localized_name;
1919 let _: Vec<crate::bindings::LocaleOverrides> = CurrencyInfo.locale_overrides;
1920 }
1921 {
1922 let ExternalInputParser = None::<crate::bindings::ExternalInputParser>.unwrap();
1923 let _: String = ExternalInputParser.provider_id;
1924 let _: String = ExternalInputParser.input_regex;
1925 let _: String = ExternalInputParser.parser_url;
1926 }
1927 {
1928 let FiatCurrency = None::<crate::bindings::FiatCurrency>.unwrap();
1929 let _: String = FiatCurrency.id;
1930 let _: crate::bindings::CurrencyInfo = FiatCurrency.info;
1931 }
1932 match None::<crate::bindings::InputType>.unwrap() {
1933 crate::bindings::InputType::BitcoinAddress { address } => {
1934 let _: crate::bindings::BitcoinAddressData = address;
1935 }
1936 crate::bindings::InputType::LiquidAddress { address } => {
1937 let _: crate::bindings::LiquidAddressData = address;
1938 }
1939 crate::bindings::InputType::Bolt11 { invoice } => {
1940 let _: crate::bindings::LNInvoice = invoice;
1941 }
1942 crate::bindings::InputType::Bolt12Offer {
1943 offer,
1944 bip353_address,
1945 } => {
1946 let _: crate::bindings::LNOffer = offer;
1947 let _: Option<String> = bip353_address;
1948 }
1949 crate::bindings::InputType::NodeId { node_id } => {
1950 let _: String = node_id;
1951 }
1952 crate::bindings::InputType::Url { url } => {
1953 let _: String = url;
1954 }
1955 crate::bindings::InputType::LnUrlPay {
1956 data,
1957 bip353_address,
1958 } => {
1959 let _: crate::bindings::LnUrlPayRequestData = data;
1960 let _: Option<String> = bip353_address;
1961 }
1962 crate::bindings::InputType::LnUrlWithdraw { data } => {
1963 let _: crate::bindings::LnUrlWithdrawRequestData = data;
1964 }
1965 crate::bindings::InputType::LnUrlAuth { data } => {
1966 let _: crate::bindings::LnUrlAuthRequestData = data;
1967 }
1968 crate::bindings::InputType::LnUrlError { data } => {
1969 let _: crate::bindings::LnUrlErrorData = data;
1970 }
1971 }
1972 {
1973 let LiquidAddressData = None::<crate::bindings::LiquidAddressData>.unwrap();
1974 let _: String = LiquidAddressData.address;
1975 let _: crate::bindings::Network = LiquidAddressData.network;
1976 let _: Option<String> = LiquidAddressData.asset_id;
1977 let _: Option<f64> = LiquidAddressData.amount;
1978 let _: Option<u64> = LiquidAddressData.amount_sat;
1979 let _: Option<String> = LiquidAddressData.label;
1980 let _: Option<String> = LiquidAddressData.message;
1981 }
1982 {
1983 let LNInvoice = None::<crate::bindings::LNInvoice>.unwrap();
1984 let _: String = LNInvoice.bolt11;
1985 let _: crate::bindings::Network = LNInvoice.network;
1986 let _: String = LNInvoice.payee_pubkey;
1987 let _: String = LNInvoice.payment_hash;
1988 let _: Option<String> = LNInvoice.description;
1989 let _: Option<String> = LNInvoice.description_hash;
1990 let _: Option<u64> = LNInvoice.amount_msat;
1991 let _: u64 = LNInvoice.timestamp;
1992 let _: u64 = LNInvoice.expiry;
1993 let _: Vec<crate::bindings::RouteHint> = LNInvoice.routing_hints;
1994 let _: Vec<u8> = LNInvoice.payment_secret;
1995 let _: u64 = LNInvoice.min_final_cltv_expiry_delta;
1996 }
1997 {
1998 let LNOffer = None::<crate::bindings::LNOffer>.unwrap();
1999 let _: String = LNOffer.offer;
2000 let _: Vec<String> = LNOffer.chains;
2001 let _: Option<crate::bindings::Amount> = LNOffer.min_amount;
2002 let _: Option<String> = LNOffer.description;
2003 let _: Option<u64> = LNOffer.absolute_expiry;
2004 let _: Option<String> = LNOffer.issuer;
2005 let _: Option<String> = LNOffer.signing_pubkey;
2006 let _: Vec<crate::bindings::LnOfferBlindedPath> = LNOffer.paths;
2007 }
2008 {
2009 let LnOfferBlindedPath = None::<crate::bindings::LnOfferBlindedPath>.unwrap();
2010 let _: Vec<String> = LnOfferBlindedPath.blinded_hops;
2011 }
2012 {
2013 let LnUrlAuthRequestData = None::<crate::bindings::LnUrlAuthRequestData>.unwrap();
2014 let _: String = LnUrlAuthRequestData.k1;
2015 let _: Option<String> = LnUrlAuthRequestData.action;
2016 let _: String = LnUrlAuthRequestData.domain;
2017 let _: String = LnUrlAuthRequestData.url;
2018 }
2019 {
2020 let LnUrlErrorData = None::<crate::bindings::LnUrlErrorData>.unwrap();
2021 let _: String = LnUrlErrorData.reason;
2022 }
2023 {
2024 let LnUrlPayErrorData = None::<crate::bindings::LnUrlPayErrorData>.unwrap();
2025 let _: String = LnUrlPayErrorData.payment_hash;
2026 let _: String = LnUrlPayErrorData.reason;
2027 }
2028 {
2029 let LnUrlPayRequestData = None::<crate::bindings::LnUrlPayRequestData>.unwrap();
2030 let _: String = LnUrlPayRequestData.callback;
2031 let _: u64 = LnUrlPayRequestData.min_sendable;
2032 let _: u64 = LnUrlPayRequestData.max_sendable;
2033 let _: String = LnUrlPayRequestData.metadata_str;
2034 let _: u16 = LnUrlPayRequestData.comment_allowed;
2035 let _: String = LnUrlPayRequestData.domain;
2036 let _: bool = LnUrlPayRequestData.allows_nostr;
2037 let _: Option<String> = LnUrlPayRequestData.nostr_pubkey;
2038 let _: Option<String> = LnUrlPayRequestData.ln_address;
2039 }
2040 {
2041 let LnUrlWithdrawRequest = None::<crate::bindings::LnUrlWithdrawRequest>.unwrap();
2042 let _: crate::bindings::LnUrlWithdrawRequestData = LnUrlWithdrawRequest.data;
2043 let _: u64 = LnUrlWithdrawRequest.amount_msat;
2044 let _: Option<String> = LnUrlWithdrawRequest.description;
2045 }
2046 {
2047 let LnUrlWithdrawRequestData = None::<crate::bindings::LnUrlWithdrawRequestData>.unwrap();
2048 let _: String = LnUrlWithdrawRequestData.callback;
2049 let _: String = LnUrlWithdrawRequestData.k1;
2050 let _: String = LnUrlWithdrawRequestData.default_description;
2051 let _: u64 = LnUrlWithdrawRequestData.min_withdrawable;
2052 let _: u64 = LnUrlWithdrawRequestData.max_withdrawable;
2053 }
2054 {
2055 let LocaleOverrides = None::<crate::bindings::LocaleOverrides>.unwrap();
2056 let _: String = LocaleOverrides.locale;
2057 let _: Option<u32> = LocaleOverrides.spacing;
2058 let _: crate::bindings::Symbol = LocaleOverrides.symbol;
2059 }
2060 {
2061 let LocalizedName = None::<crate::bindings::LocalizedName>.unwrap();
2062 let _: String = LocalizedName.locale;
2063 let _: String = LocalizedName.name;
2064 }
2065 {
2066 let MessageSuccessActionData = None::<crate::bindings::MessageSuccessActionData>.unwrap();
2067 let _: String = MessageSuccessActionData.message;
2068 }
2069 {
2070 let Rate = None::<crate::bindings::Rate>.unwrap();
2071 let _: String = Rate.coin;
2072 let _: f64 = Rate.value;
2073 }
2074 {
2075 let RouteHint = None::<crate::bindings::RouteHint>.unwrap();
2076 let _: Vec<crate::bindings::RouteHintHop> = RouteHint.hops;
2077 }
2078 {
2079 let RouteHintHop = None::<crate::bindings::RouteHintHop>.unwrap();
2080 let _: String = RouteHintHop.src_node_id;
2081 let _: String = RouteHintHop.short_channel_id;
2082 let _: u32 = RouteHintHop.fees_base_msat;
2083 let _: u32 = RouteHintHop.fees_proportional_millionths;
2084 let _: u64 = RouteHintHop.cltv_expiry_delta;
2085 let _: Option<u64> = RouteHintHop.htlc_minimum_msat;
2086 let _: Option<u64> = RouteHintHop.htlc_maximum_msat;
2087 }
2088 match None::<crate::bindings::SuccessAction>.unwrap() {
2089 crate::bindings::SuccessAction::Aes { data } => {
2090 let _: crate::bindings::AesSuccessActionData = data;
2091 }
2092 crate::bindings::SuccessAction::Message { data } => {
2093 let _: crate::bindings::MessageSuccessActionData = data;
2094 }
2095 crate::bindings::SuccessAction::Url { data } => {
2096 let _: crate::bindings::UrlSuccessActionData = data;
2097 }
2098 }
2099 match None::<crate::bindings::SuccessActionProcessed>.unwrap() {
2100 crate::bindings::SuccessActionProcessed::Aes { result } => {
2101 let _: crate::bindings::AesSuccessActionDataResult = result;
2102 }
2103 crate::bindings::SuccessActionProcessed::Message { data } => {
2104 let _: crate::bindings::MessageSuccessActionData = data;
2105 }
2106 crate::bindings::SuccessActionProcessed::Url { data } => {
2107 let _: crate::bindings::UrlSuccessActionData = data;
2108 }
2109 }
2110 {
2111 let Symbol = None::<crate::bindings::Symbol>.unwrap();
2112 let _: Option<String> = Symbol.grapheme;
2113 let _: Option<String> = Symbol.template;
2114 let _: Option<bool> = Symbol.rtl;
2115 let _: Option<u32> = Symbol.position;
2116 }
2117 {
2118 let UrlSuccessActionData = None::<crate::bindings::UrlSuccessActionData>.unwrap();
2119 let _: String = UrlSuccessActionData.description;
2120 let _: String = UrlSuccessActionData.url;
2121 let _: bool = UrlSuccessActionData.matches_callback_domain;
2122 }
2123};
2124
2125impl CstDecode<bool> for bool {
2128 fn cst_decode(self) -> bool {
2130 self
2131 }
2132}
2133impl CstDecode<crate::model::BuyBitcoinProvider> for i32 {
2134 fn cst_decode(self) -> crate::model::BuyBitcoinProvider {
2136 match self {
2137 0 => crate::model::BuyBitcoinProvider::Moonpay,
2138 _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", self),
2139 }
2140 }
2141}
2142impl CstDecode<f64> for f64 {
2143 fn cst_decode(self) -> f64 {
2145 self
2146 }
2147}
2148impl CstDecode<i32> for i32 {
2149 fn cst_decode(self) -> i32 {
2151 self
2152 }
2153}
2154impl CstDecode<i64> for i64 {
2155 fn cst_decode(self) -> i64 {
2157 self
2158 }
2159}
2160impl CstDecode<crate::model::LiquidNetwork> for i32 {
2161 fn cst_decode(self) -> crate::model::LiquidNetwork {
2163 match self {
2164 0 => crate::model::LiquidNetwork::Mainnet,
2165 1 => crate::model::LiquidNetwork::Testnet,
2166 2 => crate::model::LiquidNetwork::Regtest,
2167 _ => unreachable!("Invalid variant for LiquidNetwork: {}", self),
2168 }
2169 }
2170}
2171impl CstDecode<crate::bindings::Network> for i32 {
2172 fn cst_decode(self) -> crate::bindings::Network {
2174 match self {
2175 0 => crate::bindings::Network::Bitcoin,
2176 1 => crate::bindings::Network::Testnet,
2177 2 => crate::bindings::Network::Signet,
2178 3 => crate::bindings::Network::Regtest,
2179 _ => unreachable!("Invalid variant for Network: {}", self),
2180 }
2181 }
2182}
2183impl CstDecode<crate::model::PaymentMethod> for i32 {
2184 fn cst_decode(self) -> crate::model::PaymentMethod {
2186 match self {
2187 0 => crate::model::PaymentMethod::Lightning,
2188 1 => crate::model::PaymentMethod::BitcoinAddress,
2189 2 => crate::model::PaymentMethod::LiquidAddress,
2190 _ => unreachable!("Invalid variant for PaymentMethod: {}", self),
2191 }
2192 }
2193}
2194impl CstDecode<crate::model::PaymentState> for i32 {
2195 fn cst_decode(self) -> crate::model::PaymentState {
2197 match self {
2198 0 => crate::model::PaymentState::Created,
2199 1 => crate::model::PaymentState::Pending,
2200 2 => crate::model::PaymentState::Complete,
2201 3 => crate::model::PaymentState::Failed,
2202 4 => crate::model::PaymentState::TimedOut,
2203 5 => crate::model::PaymentState::Refundable,
2204 6 => crate::model::PaymentState::RefundPending,
2205 7 => crate::model::PaymentState::WaitingFeeAcceptance,
2206 _ => unreachable!("Invalid variant for PaymentState: {}", self),
2207 }
2208 }
2209}
2210impl CstDecode<crate::model::PaymentType> for i32 {
2211 fn cst_decode(self) -> crate::model::PaymentType {
2213 match self {
2214 0 => crate::model::PaymentType::Receive,
2215 1 => crate::model::PaymentType::Send,
2216 _ => unreachable!("Invalid variant for PaymentType: {}", self),
2217 }
2218 }
2219}
2220impl CstDecode<u16> for u16 {
2221 fn cst_decode(self) -> u16 {
2223 self
2224 }
2225}
2226impl CstDecode<u32> for u32 {
2227 fn cst_decode(self) -> u32 {
2229 self
2230 }
2231}
2232impl CstDecode<u64> for u64 {
2233 fn cst_decode(self) -> u64 {
2235 self
2236 }
2237}
2238impl CstDecode<u8> for u8 {
2239 fn cst_decode(self) -> u8 {
2241 self
2242 }
2243}
2244impl CstDecode<usize> for usize {
2245 fn cst_decode(self) -> usize {
2247 self
2248 }
2249}
2250impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
2251 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2253 let mut inner = <String>::sse_decode(deserializer);
2254 return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
2255 }
2256}
2257
2258impl SseDecode for BindingLiquidSdk {
2259 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2261 let mut inner = <RustOpaqueNom<
2262 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
2263 >>::sse_decode(deserializer);
2264 return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
2265 }
2266}
2267
2268impl SseDecode
2269 for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
2270{
2271 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2273 let mut inner = <usize>::sse_decode(deserializer);
2274 return unsafe { decode_rust_opaque_nom(inner) };
2275 }
2276}
2277
2278impl SseDecode
2279 for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
2280{
2281 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2283 let mut inner = <String>::sse_decode(deserializer);
2284 return StreamSink::deserialize(inner);
2285 }
2286}
2287
2288impl SseDecode
2289 for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
2290{
2291 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2293 let mut inner = <String>::sse_decode(deserializer);
2294 return StreamSink::deserialize(inner);
2295 }
2296}
2297
2298impl SseDecode for String {
2299 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2301 let mut inner = <Vec<u8>>::sse_decode(deserializer);
2302 return String::from_utf8(inner).unwrap();
2303 }
2304}
2305
2306impl SseDecode for crate::model::AcceptPaymentProposedFeesRequest {
2307 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2309 let mut var_response =
2310 <crate::model::FetchPaymentProposedFeesResponse>::sse_decode(deserializer);
2311 return crate::model::AcceptPaymentProposedFeesRequest {
2312 response: var_response,
2313 };
2314 }
2315}
2316
2317impl SseDecode for crate::bindings::AesSuccessActionData {
2318 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2320 let mut var_description = <String>::sse_decode(deserializer);
2321 let mut var_ciphertext = <String>::sse_decode(deserializer);
2322 let mut var_iv = <String>::sse_decode(deserializer);
2323 return crate::bindings::AesSuccessActionData {
2324 description: var_description,
2325 ciphertext: var_ciphertext,
2326 iv: var_iv,
2327 };
2328 }
2329}
2330
2331impl SseDecode for crate::bindings::AesSuccessActionDataDecrypted {
2332 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2334 let mut var_description = <String>::sse_decode(deserializer);
2335 let mut var_plaintext = <String>::sse_decode(deserializer);
2336 return crate::bindings::AesSuccessActionDataDecrypted {
2337 description: var_description,
2338 plaintext: var_plaintext,
2339 };
2340 }
2341}
2342
2343impl SseDecode for crate::bindings::AesSuccessActionDataResult {
2344 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2346 let mut tag_ = <i32>::sse_decode(deserializer);
2347 match tag_ {
2348 0 => {
2349 let mut var_data =
2350 <crate::bindings::AesSuccessActionDataDecrypted>::sse_decode(deserializer);
2351 return crate::bindings::AesSuccessActionDataResult::Decrypted { data: var_data };
2352 }
2353 1 => {
2354 let mut var_reason = <String>::sse_decode(deserializer);
2355 return crate::bindings::AesSuccessActionDataResult::ErrorStatus {
2356 reason: var_reason,
2357 };
2358 }
2359 _ => {
2360 unimplemented!("");
2361 }
2362 }
2363 }
2364}
2365
2366impl SseDecode for crate::bindings::Amount {
2367 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2369 let mut tag_ = <i32>::sse_decode(deserializer);
2370 match tag_ {
2371 0 => {
2372 let mut var_amountMsat = <u64>::sse_decode(deserializer);
2373 return crate::bindings::Amount::Bitcoin {
2374 amount_msat: var_amountMsat,
2375 };
2376 }
2377 1 => {
2378 let mut var_iso4217Code = <String>::sse_decode(deserializer);
2379 let mut var_fractionalAmount = <u64>::sse_decode(deserializer);
2380 return crate::bindings::Amount::Currency {
2381 iso4217_code: var_iso4217Code,
2382 fractional_amount: var_fractionalAmount,
2383 };
2384 }
2385 _ => {
2386 unimplemented!("");
2387 }
2388 }
2389 }
2390}
2391
2392impl SseDecode for crate::model::AssetBalance {
2393 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2395 let mut var_assetId = <String>::sse_decode(deserializer);
2396 let mut var_balanceSat = <u64>::sse_decode(deserializer);
2397 let mut var_name = <Option<String>>::sse_decode(deserializer);
2398 let mut var_ticker = <Option<String>>::sse_decode(deserializer);
2399 let mut var_balance = <Option<f64>>::sse_decode(deserializer);
2400 return crate::model::AssetBalance {
2401 asset_id: var_assetId,
2402 balance_sat: var_balanceSat,
2403 name: var_name,
2404 ticker: var_ticker,
2405 balance: var_balance,
2406 };
2407 }
2408}
2409
2410impl SseDecode for crate::model::AssetInfo {
2411 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2413 let mut var_name = <String>::sse_decode(deserializer);
2414 let mut var_ticker = <String>::sse_decode(deserializer);
2415 let mut var_amount = <f64>::sse_decode(deserializer);
2416 let mut var_fees = <Option<f64>>::sse_decode(deserializer);
2417 return crate::model::AssetInfo {
2418 name: var_name,
2419 ticker: var_ticker,
2420 amount: var_amount,
2421 fees: var_fees,
2422 };
2423 }
2424}
2425
2426impl SseDecode for crate::model::AssetMetadata {
2427 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2429 let mut var_assetId = <String>::sse_decode(deserializer);
2430 let mut var_name = <String>::sse_decode(deserializer);
2431 let mut var_ticker = <String>::sse_decode(deserializer);
2432 let mut var_precision = <u8>::sse_decode(deserializer);
2433 let mut var_fiatId = <Option<String>>::sse_decode(deserializer);
2434 return crate::model::AssetMetadata {
2435 asset_id: var_assetId,
2436 name: var_name,
2437 ticker: var_ticker,
2438 precision: var_precision,
2439 fiat_id: var_fiatId,
2440 };
2441 }
2442}
2443
2444impl SseDecode for crate::model::BackupRequest {
2445 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2447 let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
2448 return crate::model::BackupRequest {
2449 backup_path: var_backupPath,
2450 };
2451 }
2452}
2453
2454impl SseDecode for crate::bindings::BindingEventListener {
2455 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2457 let mut var_stream = <StreamSink<
2458 crate::model::SdkEvent,
2459 flutter_rust_bridge::for_generated::DcoCodec,
2460 >>::sse_decode(deserializer);
2461 return crate::bindings::BindingEventListener { stream: var_stream };
2462 }
2463}
2464
2465impl SseDecode for crate::bindings::BitcoinAddressData {
2466 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2468 let mut var_address = <String>::sse_decode(deserializer);
2469 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2470 let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2471 let mut var_label = <Option<String>>::sse_decode(deserializer);
2472 let mut var_message = <Option<String>>::sse_decode(deserializer);
2473 return crate::bindings::BitcoinAddressData {
2474 address: var_address,
2475 network: var_network,
2476 amount_sat: var_amountSat,
2477 label: var_label,
2478 message: var_message,
2479 };
2480 }
2481}
2482
2483impl SseDecode for crate::model::BlockchainExplorer {
2484 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2486 let mut tag_ = <i32>::sse_decode(deserializer);
2487 match tag_ {
2488 0 => {
2489 let mut var_url = <String>::sse_decode(deserializer);
2490 return crate::model::BlockchainExplorer::Electrum { url: var_url };
2491 }
2492 1 => {
2493 let mut var_url = <String>::sse_decode(deserializer);
2494 let mut var_useWaterfalls = <bool>::sse_decode(deserializer);
2495 return crate::model::BlockchainExplorer::Esplora {
2496 url: var_url,
2497 use_waterfalls: var_useWaterfalls,
2498 };
2499 }
2500 _ => {
2501 unimplemented!("");
2502 }
2503 }
2504 }
2505}
2506
2507impl SseDecode for crate::model::BlockchainInfo {
2508 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2510 let mut var_liquidTip = <u32>::sse_decode(deserializer);
2511 let mut var_bitcoinTip = <u32>::sse_decode(deserializer);
2512 return crate::model::BlockchainInfo {
2513 liquid_tip: var_liquidTip,
2514 bitcoin_tip: var_bitcoinTip,
2515 };
2516 }
2517}
2518
2519impl SseDecode for bool {
2520 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2522 deserializer.cursor.read_u8().unwrap() != 0
2523 }
2524}
2525
2526impl SseDecode for crate::model::BuyBitcoinProvider {
2527 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2529 let mut inner = <i32>::sse_decode(deserializer);
2530 return match inner {
2531 0 => crate::model::BuyBitcoinProvider::Moonpay,
2532 _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", inner),
2533 };
2534 }
2535}
2536
2537impl SseDecode for crate::model::BuyBitcoinRequest {
2538 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2540 let mut var_prepareResponse =
2541 <crate::model::PrepareBuyBitcoinResponse>::sse_decode(deserializer);
2542 let mut var_redirectUrl = <Option<String>>::sse_decode(deserializer);
2543 return crate::model::BuyBitcoinRequest {
2544 prepare_response: var_prepareResponse,
2545 redirect_url: var_redirectUrl,
2546 };
2547 }
2548}
2549
2550impl SseDecode for crate::model::CheckMessageRequest {
2551 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2553 let mut var_message = <String>::sse_decode(deserializer);
2554 let mut var_pubkey = <String>::sse_decode(deserializer);
2555 let mut var_signature = <String>::sse_decode(deserializer);
2556 return crate::model::CheckMessageRequest {
2557 message: var_message,
2558 pubkey: var_pubkey,
2559 signature: var_signature,
2560 };
2561 }
2562}
2563
2564impl SseDecode for crate::model::CheckMessageResponse {
2565 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2567 let mut var_isValid = <bool>::sse_decode(deserializer);
2568 return crate::model::CheckMessageResponse {
2569 is_valid: var_isValid,
2570 };
2571 }
2572}
2573
2574impl SseDecode for crate::model::Config {
2575 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2577 let mut var_liquidExplorer = <crate::model::BlockchainExplorer>::sse_decode(deserializer);
2578 let mut var_bitcoinExplorer = <crate::model::BlockchainExplorer>::sse_decode(deserializer);
2579 let mut var_workingDir = <String>::sse_decode(deserializer);
2580 let mut var_cacheDir = <Option<String>>::sse_decode(deserializer);
2581 let mut var_network = <crate::model::LiquidNetwork>::sse_decode(deserializer);
2582 let mut var_paymentTimeoutSec = <u64>::sse_decode(deserializer);
2583 let mut var_syncServiceUrl = <Option<String>>::sse_decode(deserializer);
2584 let mut var_zeroConfMaxAmountSat = <Option<u64>>::sse_decode(deserializer);
2585 let mut var_breezApiKey = <Option<String>>::sse_decode(deserializer);
2586 let mut var_externalInputParsers =
2587 <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_decode(deserializer);
2588 let mut var_useDefaultExternalInputParsers = <bool>::sse_decode(deserializer);
2589 let mut var_onchainFeeRateLeewaySatPerVbyte = <Option<u32>>::sse_decode(deserializer);
2590 let mut var_assetMetadata =
2591 <Option<Vec<crate::model::AssetMetadata>>>::sse_decode(deserializer);
2592 let mut var_sideswapApiKey = <Option<String>>::sse_decode(deserializer);
2593 return crate::model::Config {
2594 liquid_explorer: var_liquidExplorer,
2595 bitcoin_explorer: var_bitcoinExplorer,
2596 working_dir: var_workingDir,
2597 cache_dir: var_cacheDir,
2598 network: var_network,
2599 payment_timeout_sec: var_paymentTimeoutSec,
2600 sync_service_url: var_syncServiceUrl,
2601 zero_conf_max_amount_sat: var_zeroConfMaxAmountSat,
2602 breez_api_key: var_breezApiKey,
2603 external_input_parsers: var_externalInputParsers,
2604 use_default_external_input_parsers: var_useDefaultExternalInputParsers,
2605 onchain_fee_rate_leeway_sat_per_vbyte: var_onchainFeeRateLeewaySatPerVbyte,
2606 asset_metadata: var_assetMetadata,
2607 sideswap_api_key: var_sideswapApiKey,
2608 };
2609 }
2610}
2611
2612impl SseDecode for crate::model::ConnectRequest {
2613 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2615 let mut var_config = <crate::model::Config>::sse_decode(deserializer);
2616 let mut var_mnemonic = <Option<String>>::sse_decode(deserializer);
2617 let mut var_passphrase = <Option<String>>::sse_decode(deserializer);
2618 let mut var_seed = <Option<Vec<u8>>>::sse_decode(deserializer);
2619 return crate::model::ConnectRequest {
2620 config: var_config,
2621 mnemonic: var_mnemonic,
2622 passphrase: var_passphrase,
2623 seed: var_seed,
2624 };
2625 }
2626}
2627
2628impl SseDecode for crate::bindings::CurrencyInfo {
2629 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2631 let mut var_name = <String>::sse_decode(deserializer);
2632 let mut var_fractionSize = <u32>::sse_decode(deserializer);
2633 let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
2634 let mut var_symbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2635 let mut var_uniqSymbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2636 let mut var_localizedName = <Vec<crate::bindings::LocalizedName>>::sse_decode(deserializer);
2637 let mut var_localeOverrides =
2638 <Vec<crate::bindings::LocaleOverrides>>::sse_decode(deserializer);
2639 return crate::bindings::CurrencyInfo {
2640 name: var_name,
2641 fraction_size: var_fractionSize,
2642 spacing: var_spacing,
2643 symbol: var_symbol,
2644 uniq_symbol: var_uniqSymbol,
2645 localized_name: var_localizedName,
2646 locale_overrides: var_localeOverrides,
2647 };
2648 }
2649}
2650
2651impl SseDecode for crate::bindings::ExternalInputParser {
2652 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2654 let mut var_providerId = <String>::sse_decode(deserializer);
2655 let mut var_inputRegex = <String>::sse_decode(deserializer);
2656 let mut var_parserUrl = <String>::sse_decode(deserializer);
2657 return crate::bindings::ExternalInputParser {
2658 provider_id: var_providerId,
2659 input_regex: var_inputRegex,
2660 parser_url: var_parserUrl,
2661 };
2662 }
2663}
2664
2665impl SseDecode for f64 {
2666 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2668 deserializer.cursor.read_f64::<NativeEndian>().unwrap()
2669 }
2670}
2671
2672impl SseDecode for crate::model::FetchPaymentProposedFeesRequest {
2673 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2675 let mut var_swapId = <String>::sse_decode(deserializer);
2676 return crate::model::FetchPaymentProposedFeesRequest {
2677 swap_id: var_swapId,
2678 };
2679 }
2680}
2681
2682impl SseDecode for crate::model::FetchPaymentProposedFeesResponse {
2683 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2685 let mut var_swapId = <String>::sse_decode(deserializer);
2686 let mut var_feesSat = <u64>::sse_decode(deserializer);
2687 let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
2688 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
2689 return crate::model::FetchPaymentProposedFeesResponse {
2690 swap_id: var_swapId,
2691 fees_sat: var_feesSat,
2692 payer_amount_sat: var_payerAmountSat,
2693 receiver_amount_sat: var_receiverAmountSat,
2694 };
2695 }
2696}
2697
2698impl SseDecode for crate::bindings::FiatCurrency {
2699 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2701 let mut var_id = <String>::sse_decode(deserializer);
2702 let mut var_info = <crate::bindings::CurrencyInfo>::sse_decode(deserializer);
2703 return crate::bindings::FiatCurrency {
2704 id: var_id,
2705 info: var_info,
2706 };
2707 }
2708}
2709
2710impl SseDecode for crate::model::GetInfoResponse {
2711 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2713 let mut var_walletInfo = <crate::model::WalletInfo>::sse_decode(deserializer);
2714 let mut var_blockchainInfo = <crate::model::BlockchainInfo>::sse_decode(deserializer);
2715 return crate::model::GetInfoResponse {
2716 wallet_info: var_walletInfo,
2717 blockchain_info: var_blockchainInfo,
2718 };
2719 }
2720}
2721
2722impl SseDecode for crate::model::GetPaymentRequest {
2723 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2725 let mut tag_ = <i32>::sse_decode(deserializer);
2726 match tag_ {
2727 0 => {
2728 let mut var_paymentHash = <String>::sse_decode(deserializer);
2729 return crate::model::GetPaymentRequest::PaymentHash {
2730 payment_hash: var_paymentHash,
2731 };
2732 }
2733 1 => {
2734 let mut var_swapId = <String>::sse_decode(deserializer);
2735 return crate::model::GetPaymentRequest::SwapId {
2736 swap_id: var_swapId,
2737 };
2738 }
2739 _ => {
2740 unimplemented!("");
2741 }
2742 }
2743 }
2744}
2745
2746impl SseDecode for i32 {
2747 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2749 deserializer.cursor.read_i32::<NativeEndian>().unwrap()
2750 }
2751}
2752
2753impl SseDecode for i64 {
2754 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2756 deserializer.cursor.read_i64::<NativeEndian>().unwrap()
2757 }
2758}
2759
2760impl SseDecode for crate::bindings::InputType {
2761 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2763 let mut tag_ = <i32>::sse_decode(deserializer);
2764 match tag_ {
2765 0 => {
2766 let mut var_address =
2767 <crate::bindings::BitcoinAddressData>::sse_decode(deserializer);
2768 return crate::bindings::InputType::BitcoinAddress {
2769 address: var_address,
2770 };
2771 }
2772 1 => {
2773 let mut var_address =
2774 <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
2775 return crate::bindings::InputType::LiquidAddress {
2776 address: var_address,
2777 };
2778 }
2779 2 => {
2780 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
2781 return crate::bindings::InputType::Bolt11 {
2782 invoice: var_invoice,
2783 };
2784 }
2785 3 => {
2786 let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
2787 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2788 return crate::bindings::InputType::Bolt12Offer {
2789 offer: var_offer,
2790 bip353_address: var_bip353Address,
2791 };
2792 }
2793 4 => {
2794 let mut var_nodeId = <String>::sse_decode(deserializer);
2795 return crate::bindings::InputType::NodeId {
2796 node_id: var_nodeId,
2797 };
2798 }
2799 5 => {
2800 let mut var_url = <String>::sse_decode(deserializer);
2801 return crate::bindings::InputType::Url { url: var_url };
2802 }
2803 6 => {
2804 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
2805 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2806 return crate::bindings::InputType::LnUrlPay {
2807 data: var_data,
2808 bip353_address: var_bip353Address,
2809 };
2810 }
2811 7 => {
2812 let mut var_data =
2813 <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
2814 return crate::bindings::InputType::LnUrlWithdraw { data: var_data };
2815 }
2816 8 => {
2817 let mut var_data =
2818 <crate::bindings::LnUrlAuthRequestData>::sse_decode(deserializer);
2819 return crate::bindings::InputType::LnUrlAuth { data: var_data };
2820 }
2821 9 => {
2822 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
2823 return crate::bindings::InputType::LnUrlError { data: var_data };
2824 }
2825 _ => {
2826 unimplemented!("");
2827 }
2828 }
2829 }
2830}
2831
2832impl SseDecode for crate::model::LightningPaymentLimitsResponse {
2833 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2835 let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
2836 let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
2837 return crate::model::LightningPaymentLimitsResponse {
2838 send: var_send,
2839 receive: var_receive,
2840 };
2841 }
2842}
2843
2844impl SseDecode for crate::model::Limits {
2845 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2847 let mut var_minSat = <u64>::sse_decode(deserializer);
2848 let mut var_maxSat = <u64>::sse_decode(deserializer);
2849 let mut var_maxZeroConfSat = <u64>::sse_decode(deserializer);
2850 return crate::model::Limits {
2851 min_sat: var_minSat,
2852 max_sat: var_maxSat,
2853 max_zero_conf_sat: var_maxZeroConfSat,
2854 };
2855 }
2856}
2857
2858impl SseDecode for crate::bindings::LiquidAddressData {
2859 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2861 let mut var_address = <String>::sse_decode(deserializer);
2862 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2863 let mut var_assetId = <Option<String>>::sse_decode(deserializer);
2864 let mut var_amount = <Option<f64>>::sse_decode(deserializer);
2865 let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2866 let mut var_label = <Option<String>>::sse_decode(deserializer);
2867 let mut var_message = <Option<String>>::sse_decode(deserializer);
2868 return crate::bindings::LiquidAddressData {
2869 address: var_address,
2870 network: var_network,
2871 asset_id: var_assetId,
2872 amount: var_amount,
2873 amount_sat: var_amountSat,
2874 label: var_label,
2875 message: var_message,
2876 };
2877 }
2878}
2879
2880impl SseDecode for crate::model::LiquidNetwork {
2881 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2883 let mut inner = <i32>::sse_decode(deserializer);
2884 return match inner {
2885 0 => crate::model::LiquidNetwork::Mainnet,
2886 1 => crate::model::LiquidNetwork::Testnet,
2887 2 => crate::model::LiquidNetwork::Regtest,
2888 _ => unreachable!("Invalid variant for LiquidNetwork: {}", inner),
2889 };
2890 }
2891}
2892
2893impl SseDecode for Vec<String> {
2894 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2896 let mut len_ = <i32>::sse_decode(deserializer);
2897 let mut ans_ = vec![];
2898 for idx_ in 0..len_ {
2899 ans_.push(<String>::sse_decode(deserializer));
2900 }
2901 return ans_;
2902 }
2903}
2904
2905impl SseDecode for Vec<crate::model::AssetBalance> {
2906 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2908 let mut len_ = <i32>::sse_decode(deserializer);
2909 let mut ans_ = vec![];
2910 for idx_ in 0..len_ {
2911 ans_.push(<crate::model::AssetBalance>::sse_decode(deserializer));
2912 }
2913 return ans_;
2914 }
2915}
2916
2917impl SseDecode for Vec<crate::model::AssetMetadata> {
2918 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2920 let mut len_ = <i32>::sse_decode(deserializer);
2921 let mut ans_ = vec![];
2922 for idx_ in 0..len_ {
2923 ans_.push(<crate::model::AssetMetadata>::sse_decode(deserializer));
2924 }
2925 return ans_;
2926 }
2927}
2928
2929impl SseDecode for Vec<crate::bindings::ExternalInputParser> {
2930 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2932 let mut len_ = <i32>::sse_decode(deserializer);
2933 let mut ans_ = vec![];
2934 for idx_ in 0..len_ {
2935 ans_.push(<crate::bindings::ExternalInputParser>::sse_decode(
2936 deserializer,
2937 ));
2938 }
2939 return ans_;
2940 }
2941}
2942
2943impl SseDecode for Vec<crate::bindings::FiatCurrency> {
2944 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2946 let mut len_ = <i32>::sse_decode(deserializer);
2947 let mut ans_ = vec![];
2948 for idx_ in 0..len_ {
2949 ans_.push(<crate::bindings::FiatCurrency>::sse_decode(deserializer));
2950 }
2951 return ans_;
2952 }
2953}
2954
2955impl SseDecode for Vec<crate::bindings::LnOfferBlindedPath> {
2956 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2958 let mut len_ = <i32>::sse_decode(deserializer);
2959 let mut ans_ = vec![];
2960 for idx_ in 0..len_ {
2961 ans_.push(<crate::bindings::LnOfferBlindedPath>::sse_decode(
2962 deserializer,
2963 ));
2964 }
2965 return ans_;
2966 }
2967}
2968
2969impl SseDecode for Vec<crate::bindings::LocaleOverrides> {
2970 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2972 let mut len_ = <i32>::sse_decode(deserializer);
2973 let mut ans_ = vec![];
2974 for idx_ in 0..len_ {
2975 ans_.push(<crate::bindings::LocaleOverrides>::sse_decode(deserializer));
2976 }
2977 return ans_;
2978 }
2979}
2980
2981impl SseDecode for Vec<crate::bindings::LocalizedName> {
2982 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2984 let mut len_ = <i32>::sse_decode(deserializer);
2985 let mut ans_ = vec![];
2986 for idx_ in 0..len_ {
2987 ans_.push(<crate::bindings::LocalizedName>::sse_decode(deserializer));
2988 }
2989 return ans_;
2990 }
2991}
2992
2993impl SseDecode for Vec<crate::model::Payment> {
2994 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2996 let mut len_ = <i32>::sse_decode(deserializer);
2997 let mut ans_ = vec![];
2998 for idx_ in 0..len_ {
2999 ans_.push(<crate::model::Payment>::sse_decode(deserializer));
3000 }
3001 return ans_;
3002 }
3003}
3004
3005impl SseDecode for crate::model::ListPaymentDetails {
3006 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3008 let mut tag_ = <i32>::sse_decode(deserializer);
3009 match tag_ {
3010 0 => {
3011 let mut var_assetId = <Option<String>>::sse_decode(deserializer);
3012 let mut var_destination = <Option<String>>::sse_decode(deserializer);
3013 return crate::model::ListPaymentDetails::Liquid {
3014 asset_id: var_assetId,
3015 destination: var_destination,
3016 };
3017 }
3018 1 => {
3019 let mut var_address = <Option<String>>::sse_decode(deserializer);
3020 return crate::model::ListPaymentDetails::Bitcoin {
3021 address: var_address,
3022 };
3023 }
3024 _ => {
3025 unimplemented!("");
3026 }
3027 }
3028 }
3029}
3030
3031impl SseDecode for Vec<crate::model::PaymentState> {
3032 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3034 let mut len_ = <i32>::sse_decode(deserializer);
3035 let mut ans_ = vec![];
3036 for idx_ in 0..len_ {
3037 ans_.push(<crate::model::PaymentState>::sse_decode(deserializer));
3038 }
3039 return ans_;
3040 }
3041}
3042
3043impl SseDecode for Vec<crate::model::PaymentType> {
3044 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3046 let mut len_ = <i32>::sse_decode(deserializer);
3047 let mut ans_ = vec![];
3048 for idx_ in 0..len_ {
3049 ans_.push(<crate::model::PaymentType>::sse_decode(deserializer));
3050 }
3051 return ans_;
3052 }
3053}
3054
3055impl SseDecode for crate::model::ListPaymentsRequest {
3056 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3058 let mut var_filters = <Option<Vec<crate::model::PaymentType>>>::sse_decode(deserializer);
3059 let mut var_states = <Option<Vec<crate::model::PaymentState>>>::sse_decode(deserializer);
3060 let mut var_fromTimestamp = <Option<i64>>::sse_decode(deserializer);
3061 let mut var_toTimestamp = <Option<i64>>::sse_decode(deserializer);
3062 let mut var_offset = <Option<u32>>::sse_decode(deserializer);
3063 let mut var_limit = <Option<u32>>::sse_decode(deserializer);
3064 let mut var_details = <Option<crate::model::ListPaymentDetails>>::sse_decode(deserializer);
3065 let mut var_sortAscending = <Option<bool>>::sse_decode(deserializer);
3066 return crate::model::ListPaymentsRequest {
3067 filters: var_filters,
3068 states: var_states,
3069 from_timestamp: var_fromTimestamp,
3070 to_timestamp: var_toTimestamp,
3071 offset: var_offset,
3072 limit: var_limit,
3073 details: var_details,
3074 sort_ascending: var_sortAscending,
3075 };
3076 }
3077}
3078
3079impl SseDecode for Vec<u8> {
3080 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3082 let mut len_ = <i32>::sse_decode(deserializer);
3083 let mut ans_ = vec![];
3084 for idx_ in 0..len_ {
3085 ans_.push(<u8>::sse_decode(deserializer));
3086 }
3087 return ans_;
3088 }
3089}
3090
3091impl SseDecode for Vec<crate::bindings::Rate> {
3092 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3094 let mut len_ = <i32>::sse_decode(deserializer);
3095 let mut ans_ = vec![];
3096 for idx_ in 0..len_ {
3097 ans_.push(<crate::bindings::Rate>::sse_decode(deserializer));
3098 }
3099 return ans_;
3100 }
3101}
3102
3103impl SseDecode for Vec<crate::model::RefundableSwap> {
3104 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3106 let mut len_ = <i32>::sse_decode(deserializer);
3107 let mut ans_ = vec![];
3108 for idx_ in 0..len_ {
3109 ans_.push(<crate::model::RefundableSwap>::sse_decode(deserializer));
3110 }
3111 return ans_;
3112 }
3113}
3114
3115impl SseDecode for Vec<crate::bindings::RouteHint> {
3116 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3118 let mut len_ = <i32>::sse_decode(deserializer);
3119 let mut ans_ = vec![];
3120 for idx_ in 0..len_ {
3121 ans_.push(<crate::bindings::RouteHint>::sse_decode(deserializer));
3122 }
3123 return ans_;
3124 }
3125}
3126
3127impl SseDecode for Vec<crate::bindings::RouteHintHop> {
3128 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3130 let mut len_ = <i32>::sse_decode(deserializer);
3131 let mut ans_ = vec![];
3132 for idx_ in 0..len_ {
3133 ans_.push(<crate::bindings::RouteHintHop>::sse_decode(deserializer));
3134 }
3135 return ans_;
3136 }
3137}
3138
3139impl SseDecode for crate::bindings::LNInvoice {
3140 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3142 let mut var_bolt11 = <String>::sse_decode(deserializer);
3143 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
3144 let mut var_payeePubkey = <String>::sse_decode(deserializer);
3145 let mut var_paymentHash = <String>::sse_decode(deserializer);
3146 let mut var_description = <Option<String>>::sse_decode(deserializer);
3147 let mut var_descriptionHash = <Option<String>>::sse_decode(deserializer);
3148 let mut var_amountMsat = <Option<u64>>::sse_decode(deserializer);
3149 let mut var_timestamp = <u64>::sse_decode(deserializer);
3150 let mut var_expiry = <u64>::sse_decode(deserializer);
3151 let mut var_routingHints = <Vec<crate::bindings::RouteHint>>::sse_decode(deserializer);
3152 let mut var_paymentSecret = <Vec<u8>>::sse_decode(deserializer);
3153 let mut var_minFinalCltvExpiryDelta = <u64>::sse_decode(deserializer);
3154 return crate::bindings::LNInvoice {
3155 bolt11: var_bolt11,
3156 network: var_network,
3157 payee_pubkey: var_payeePubkey,
3158 payment_hash: var_paymentHash,
3159 description: var_description,
3160 description_hash: var_descriptionHash,
3161 amount_msat: var_amountMsat,
3162 timestamp: var_timestamp,
3163 expiry: var_expiry,
3164 routing_hints: var_routingHints,
3165 payment_secret: var_paymentSecret,
3166 min_final_cltv_expiry_delta: var_minFinalCltvExpiryDelta,
3167 };
3168 }
3169}
3170
3171impl SseDecode for crate::bindings::LNOffer {
3172 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3174 let mut var_offer = <String>::sse_decode(deserializer);
3175 let mut var_chains = <Vec<String>>::sse_decode(deserializer);
3176 let mut var_minAmount = <Option<crate::bindings::Amount>>::sse_decode(deserializer);
3177 let mut var_description = <Option<String>>::sse_decode(deserializer);
3178 let mut var_absoluteExpiry = <Option<u64>>::sse_decode(deserializer);
3179 let mut var_issuer = <Option<String>>::sse_decode(deserializer);
3180 let mut var_signingPubkey = <Option<String>>::sse_decode(deserializer);
3181 let mut var_paths = <Vec<crate::bindings::LnOfferBlindedPath>>::sse_decode(deserializer);
3182 return crate::bindings::LNOffer {
3183 offer: var_offer,
3184 chains: var_chains,
3185 min_amount: var_minAmount,
3186 description: var_description,
3187 absolute_expiry: var_absoluteExpiry,
3188 issuer: var_issuer,
3189 signing_pubkey: var_signingPubkey,
3190 paths: var_paths,
3191 };
3192 }
3193}
3194
3195impl SseDecode for crate::bindings::LnOfferBlindedPath {
3196 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3198 let mut var_blindedHops = <Vec<String>>::sse_decode(deserializer);
3199 return crate::bindings::LnOfferBlindedPath {
3200 blinded_hops: var_blindedHops,
3201 };
3202 }
3203}
3204
3205impl SseDecode for crate::bindings::duplicates::LnUrlAuthError {
3206 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3208 let mut tag_ = <i32>::sse_decode(deserializer);
3209 match tag_ {
3210 0 => {
3211 let mut var_err = <String>::sse_decode(deserializer);
3212 return crate::bindings::duplicates::LnUrlAuthError::Generic { err: var_err };
3213 }
3214 1 => {
3215 let mut var_err = <String>::sse_decode(deserializer);
3216 return crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err: var_err };
3217 }
3218 2 => {
3219 let mut var_err = <String>::sse_decode(deserializer);
3220 return crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
3221 err: var_err,
3222 };
3223 }
3224 _ => {
3225 unimplemented!("");
3226 }
3227 }
3228 }
3229}
3230
3231impl SseDecode for crate::bindings::LnUrlAuthRequestData {
3232 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3234 let mut var_k1 = <String>::sse_decode(deserializer);
3235 let mut var_action = <Option<String>>::sse_decode(deserializer);
3236 let mut var_domain = <String>::sse_decode(deserializer);
3237 let mut var_url = <String>::sse_decode(deserializer);
3238 return crate::bindings::LnUrlAuthRequestData {
3239 k1: var_k1,
3240 action: var_action,
3241 domain: var_domain,
3242 url: var_url,
3243 };
3244 }
3245}
3246
3247impl SseDecode for crate::bindings::duplicates::LnUrlCallbackStatus {
3248 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3250 let mut tag_ = <i32>::sse_decode(deserializer);
3251 match tag_ {
3252 0 => {
3253 return crate::bindings::duplicates::LnUrlCallbackStatus::Ok;
3254 }
3255 1 => {
3256 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3257 return crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
3258 data: var_data,
3259 };
3260 }
3261 _ => {
3262 unimplemented!("");
3263 }
3264 }
3265 }
3266}
3267
3268impl SseDecode for crate::bindings::LnUrlErrorData {
3269 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3271 let mut var_reason = <String>::sse_decode(deserializer);
3272 return crate::bindings::LnUrlErrorData { reason: var_reason };
3273 }
3274}
3275
3276impl SseDecode for crate::model::LnUrlInfo {
3277 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3279 let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3280 let mut var_lnurlPayComment = <Option<String>>::sse_decode(deserializer);
3281 let mut var_lnurlPayDomain = <Option<String>>::sse_decode(deserializer);
3282 let mut var_lnurlPayMetadata = <Option<String>>::sse_decode(deserializer);
3283 let mut var_lnurlPaySuccessAction =
3284 <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3285 let mut var_lnurlPayUnprocessedSuccessAction =
3286 <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
3287 let mut var_lnurlWithdrawEndpoint = <Option<String>>::sse_decode(deserializer);
3288 return crate::model::LnUrlInfo {
3289 ln_address: var_lnAddress,
3290 lnurl_pay_comment: var_lnurlPayComment,
3291 lnurl_pay_domain: var_lnurlPayDomain,
3292 lnurl_pay_metadata: var_lnurlPayMetadata,
3293 lnurl_pay_success_action: var_lnurlPaySuccessAction,
3294 lnurl_pay_unprocessed_success_action: var_lnurlPayUnprocessedSuccessAction,
3295 lnurl_withdraw_endpoint: var_lnurlWithdrawEndpoint,
3296 };
3297 }
3298}
3299
3300impl SseDecode for crate::bindings::duplicates::LnUrlPayError {
3301 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3303 let mut tag_ = <i32>::sse_decode(deserializer);
3304 match tag_ {
3305 0 => {
3306 return crate::bindings::duplicates::LnUrlPayError::AlreadyPaid;
3307 }
3308 1 => {
3309 let mut var_err = <String>::sse_decode(deserializer);
3310 return crate::bindings::duplicates::LnUrlPayError::Generic { err: var_err };
3311 }
3312 2 => {
3313 let mut var_err = <String>::sse_decode(deserializer);
3314 return crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err: var_err };
3315 }
3316 3 => {
3317 let mut var_err = <String>::sse_decode(deserializer);
3318 return crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err: var_err };
3319 }
3320 4 => {
3321 let mut var_err = <String>::sse_decode(deserializer);
3322 return crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err: var_err };
3323 }
3324 5 => {
3325 let mut var_err = <String>::sse_decode(deserializer);
3326 return crate::bindings::duplicates::LnUrlPayError::InvalidUri { err: var_err };
3327 }
3328 6 => {
3329 let mut var_err = <String>::sse_decode(deserializer);
3330 return crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err: var_err };
3331 }
3332 7 => {
3333 let mut var_err = <String>::sse_decode(deserializer);
3334 return crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err: var_err };
3335 }
3336 8 => {
3337 let mut var_err = <String>::sse_decode(deserializer);
3338 return crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err: var_err };
3339 }
3340 9 => {
3341 let mut var_err = <String>::sse_decode(deserializer);
3342 return crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err: var_err };
3343 }
3344 10 => {
3345 let mut var_err = <String>::sse_decode(deserializer);
3346 return crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
3347 err: var_err,
3348 };
3349 }
3350 11 => {
3351 let mut var_err = <String>::sse_decode(deserializer);
3352 return crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
3353 err: var_err,
3354 };
3355 }
3356 _ => {
3357 unimplemented!("");
3358 }
3359 }
3360 }
3361}
3362
3363impl SseDecode for crate::bindings::LnUrlPayErrorData {
3364 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3366 let mut var_paymentHash = <String>::sse_decode(deserializer);
3367 let mut var_reason = <String>::sse_decode(deserializer);
3368 return crate::bindings::LnUrlPayErrorData {
3369 payment_hash: var_paymentHash,
3370 reason: var_reason,
3371 };
3372 }
3373}
3374
3375impl SseDecode for crate::model::LnUrlPayRequest {
3376 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3378 let mut var_prepareResponse =
3379 <crate::model::PrepareLnUrlPayResponse>::sse_decode(deserializer);
3380 return crate::model::LnUrlPayRequest {
3381 prepare_response: var_prepareResponse,
3382 };
3383 }
3384}
3385
3386impl SseDecode for crate::bindings::LnUrlPayRequestData {
3387 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3389 let mut var_callback = <String>::sse_decode(deserializer);
3390 let mut var_minSendable = <u64>::sse_decode(deserializer);
3391 let mut var_maxSendable = <u64>::sse_decode(deserializer);
3392 let mut var_metadataStr = <String>::sse_decode(deserializer);
3393 let mut var_commentAllowed = <u16>::sse_decode(deserializer);
3394 let mut var_domain = <String>::sse_decode(deserializer);
3395 let mut var_allowsNostr = <bool>::sse_decode(deserializer);
3396 let mut var_nostrPubkey = <Option<String>>::sse_decode(deserializer);
3397 let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3398 return crate::bindings::LnUrlPayRequestData {
3399 callback: var_callback,
3400 min_sendable: var_minSendable,
3401 max_sendable: var_maxSendable,
3402 metadata_str: var_metadataStr,
3403 comment_allowed: var_commentAllowed,
3404 domain: var_domain,
3405 allows_nostr: var_allowsNostr,
3406 nostr_pubkey: var_nostrPubkey,
3407 ln_address: var_lnAddress,
3408 };
3409 }
3410}
3411
3412impl SseDecode for crate::model::LnUrlPayResult {
3413 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3415 let mut tag_ = <i32>::sse_decode(deserializer);
3416 match tag_ {
3417 0 => {
3418 let mut var_data = <crate::model::LnUrlPaySuccessData>::sse_decode(deserializer);
3419 return crate::model::LnUrlPayResult::EndpointSuccess { data: var_data };
3420 }
3421 1 => {
3422 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3423 return crate::model::LnUrlPayResult::EndpointError { data: var_data };
3424 }
3425 2 => {
3426 let mut var_data = <crate::bindings::LnUrlPayErrorData>::sse_decode(deserializer);
3427 return crate::model::LnUrlPayResult::PayError { data: var_data };
3428 }
3429 _ => {
3430 unimplemented!("");
3431 }
3432 }
3433 }
3434}
3435
3436impl SseDecode for crate::model::LnUrlPaySuccessData {
3437 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3439 let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
3440 let mut var_successAction =
3441 <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3442 return crate::model::LnUrlPaySuccessData {
3443 payment: var_payment,
3444 success_action: var_successAction,
3445 };
3446 }
3447}
3448
3449impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawError {
3450 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3452 let mut tag_ = <i32>::sse_decode(deserializer);
3453 match tag_ {
3454 0 => {
3455 let mut var_err = <String>::sse_decode(deserializer);
3456 return crate::bindings::duplicates::LnUrlWithdrawError::Generic { err: var_err };
3457 }
3458 1 => {
3459 let mut var_err = <String>::sse_decode(deserializer);
3460 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
3461 err: var_err,
3462 };
3463 }
3464 2 => {
3465 let mut var_err = <String>::sse_decode(deserializer);
3466 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
3467 err: var_err,
3468 };
3469 }
3470 3 => {
3471 let mut var_err = <String>::sse_decode(deserializer);
3472 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
3473 err: var_err,
3474 };
3475 }
3476 4 => {
3477 let mut var_err = <String>::sse_decode(deserializer);
3478 return crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
3479 err: var_err,
3480 };
3481 }
3482 5 => {
3483 let mut var_err = <String>::sse_decode(deserializer);
3484 return crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
3485 err: var_err,
3486 };
3487 }
3488 _ => {
3489 unimplemented!("");
3490 }
3491 }
3492 }
3493}
3494
3495impl SseDecode for crate::bindings::LnUrlWithdrawRequest {
3496 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3498 let mut var_data = <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
3499 let mut var_amountMsat = <u64>::sse_decode(deserializer);
3500 let mut var_description = <Option<String>>::sse_decode(deserializer);
3501 return crate::bindings::LnUrlWithdrawRequest {
3502 data: var_data,
3503 amount_msat: var_amountMsat,
3504 description: var_description,
3505 };
3506 }
3507}
3508
3509impl SseDecode for crate::bindings::LnUrlWithdrawRequestData {
3510 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3512 let mut var_callback = <String>::sse_decode(deserializer);
3513 let mut var_k1 = <String>::sse_decode(deserializer);
3514 let mut var_defaultDescription = <String>::sse_decode(deserializer);
3515 let mut var_minWithdrawable = <u64>::sse_decode(deserializer);
3516 let mut var_maxWithdrawable = <u64>::sse_decode(deserializer);
3517 return crate::bindings::LnUrlWithdrawRequestData {
3518 callback: var_callback,
3519 k1: var_k1,
3520 default_description: var_defaultDescription,
3521 min_withdrawable: var_minWithdrawable,
3522 max_withdrawable: var_maxWithdrawable,
3523 };
3524 }
3525}
3526
3527impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawResult {
3528 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3530 let mut tag_ = <i32>::sse_decode(deserializer);
3531 match tag_ {
3532 0 => {
3533 let mut var_data =
3534 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3535 deserializer,
3536 );
3537 return crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data: var_data };
3538 }
3539 1 => {
3540 let mut var_data =
3541 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3542 deserializer,
3543 );
3544 return crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
3545 data: var_data,
3546 };
3547 }
3548 2 => {
3549 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3550 return crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
3551 data: var_data,
3552 };
3553 }
3554 _ => {
3555 unimplemented!("");
3556 }
3557 }
3558 }
3559}
3560
3561impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3562 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3564 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
3565 return crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3566 invoice: var_invoice,
3567 };
3568 }
3569}
3570
3571impl SseDecode for crate::bindings::LocaleOverrides {
3572 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3574 let mut var_locale = <String>::sse_decode(deserializer);
3575 let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
3576 let mut var_symbol = <crate::bindings::Symbol>::sse_decode(deserializer);
3577 return crate::bindings::LocaleOverrides {
3578 locale: var_locale,
3579 spacing: var_spacing,
3580 symbol: var_symbol,
3581 };
3582 }
3583}
3584
3585impl SseDecode for crate::bindings::LocalizedName {
3586 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3588 let mut var_locale = <String>::sse_decode(deserializer);
3589 let mut var_name = <String>::sse_decode(deserializer);
3590 return crate::bindings::LocalizedName {
3591 locale: var_locale,
3592 name: var_name,
3593 };
3594 }
3595}
3596
3597impl SseDecode for crate::model::LogEntry {
3598 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3600 let mut var_line = <String>::sse_decode(deserializer);
3601 let mut var_level = <String>::sse_decode(deserializer);
3602 return crate::model::LogEntry {
3603 line: var_line,
3604 level: var_level,
3605 };
3606 }
3607}
3608
3609impl SseDecode for crate::bindings::MessageSuccessActionData {
3610 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3612 let mut var_message = <String>::sse_decode(deserializer);
3613 return crate::bindings::MessageSuccessActionData {
3614 message: var_message,
3615 };
3616 }
3617}
3618
3619impl SseDecode for crate::bindings::Network {
3620 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3622 let mut inner = <i32>::sse_decode(deserializer);
3623 return match inner {
3624 0 => crate::bindings::Network::Bitcoin,
3625 1 => crate::bindings::Network::Testnet,
3626 2 => crate::bindings::Network::Signet,
3627 3 => crate::bindings::Network::Regtest,
3628 _ => unreachable!("Invalid variant for Network: {}", inner),
3629 };
3630 }
3631}
3632
3633impl SseDecode for crate::model::OnchainPaymentLimitsResponse {
3634 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3636 let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
3637 let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
3638 return crate::model::OnchainPaymentLimitsResponse {
3639 send: var_send,
3640 receive: var_receive,
3641 };
3642 }
3643}
3644
3645impl SseDecode for Option<String> {
3646 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3648 if (<bool>::sse_decode(deserializer)) {
3649 return Some(<String>::sse_decode(deserializer));
3650 } else {
3651 return None;
3652 }
3653 }
3654}
3655
3656impl SseDecode for Option<crate::bindings::Amount> {
3657 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3659 if (<bool>::sse_decode(deserializer)) {
3660 return Some(<crate::bindings::Amount>::sse_decode(deserializer));
3661 } else {
3662 return None;
3663 }
3664 }
3665}
3666
3667impl SseDecode for Option<crate::model::AssetInfo> {
3668 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3670 if (<bool>::sse_decode(deserializer)) {
3671 return Some(<crate::model::AssetInfo>::sse_decode(deserializer));
3672 } else {
3673 return None;
3674 }
3675 }
3676}
3677
3678impl SseDecode for Option<bool> {
3679 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3681 if (<bool>::sse_decode(deserializer)) {
3682 return Some(<bool>::sse_decode(deserializer));
3683 } else {
3684 return None;
3685 }
3686 }
3687}
3688
3689impl SseDecode for Option<f64> {
3690 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3692 if (<bool>::sse_decode(deserializer)) {
3693 return Some(<f64>::sse_decode(deserializer));
3694 } else {
3695 return None;
3696 }
3697 }
3698}
3699
3700impl SseDecode for Option<i64> {
3701 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3703 if (<bool>::sse_decode(deserializer)) {
3704 return Some(<i64>::sse_decode(deserializer));
3705 } else {
3706 return None;
3707 }
3708 }
3709}
3710
3711impl SseDecode for Option<crate::model::ListPaymentDetails> {
3712 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3714 if (<bool>::sse_decode(deserializer)) {
3715 return Some(<crate::model::ListPaymentDetails>::sse_decode(deserializer));
3716 } else {
3717 return None;
3718 }
3719 }
3720}
3721
3722impl SseDecode for Option<crate::model::LnUrlInfo> {
3723 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3725 if (<bool>::sse_decode(deserializer)) {
3726 return Some(<crate::model::LnUrlInfo>::sse_decode(deserializer));
3727 } else {
3728 return None;
3729 }
3730 }
3731}
3732
3733impl SseDecode for Option<crate::model::PayAmount> {
3734 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3736 if (<bool>::sse_decode(deserializer)) {
3737 return Some(<crate::model::PayAmount>::sse_decode(deserializer));
3738 } else {
3739 return None;
3740 }
3741 }
3742}
3743
3744impl SseDecode for Option<crate::model::Payment> {
3745 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3747 if (<bool>::sse_decode(deserializer)) {
3748 return Some(<crate::model::Payment>::sse_decode(deserializer));
3749 } else {
3750 return None;
3751 }
3752 }
3753}
3754
3755impl SseDecode for Option<crate::model::ReceiveAmount> {
3756 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3758 if (<bool>::sse_decode(deserializer)) {
3759 return Some(<crate::model::ReceiveAmount>::sse_decode(deserializer));
3760 } else {
3761 return None;
3762 }
3763 }
3764}
3765
3766impl SseDecode for Option<crate::bindings::SuccessAction> {
3767 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3769 if (<bool>::sse_decode(deserializer)) {
3770 return Some(<crate::bindings::SuccessAction>::sse_decode(deserializer));
3771 } else {
3772 return None;
3773 }
3774 }
3775}
3776
3777impl SseDecode for Option<crate::bindings::SuccessActionProcessed> {
3778 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3780 if (<bool>::sse_decode(deserializer)) {
3781 return Some(<crate::bindings::SuccessActionProcessed>::sse_decode(
3782 deserializer,
3783 ));
3784 } else {
3785 return None;
3786 }
3787 }
3788}
3789
3790impl SseDecode for Option<crate::bindings::Symbol> {
3791 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3793 if (<bool>::sse_decode(deserializer)) {
3794 return Some(<crate::bindings::Symbol>::sse_decode(deserializer));
3795 } else {
3796 return None;
3797 }
3798 }
3799}
3800
3801impl SseDecode for Option<u32> {
3802 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3804 if (<bool>::sse_decode(deserializer)) {
3805 return Some(<u32>::sse_decode(deserializer));
3806 } else {
3807 return None;
3808 }
3809 }
3810}
3811
3812impl SseDecode for Option<u64> {
3813 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3815 if (<bool>::sse_decode(deserializer)) {
3816 return Some(<u64>::sse_decode(deserializer));
3817 } else {
3818 return None;
3819 }
3820 }
3821}
3822
3823impl SseDecode for Option<Vec<crate::model::AssetMetadata>> {
3824 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3826 if (<bool>::sse_decode(deserializer)) {
3827 return Some(<Vec<crate::model::AssetMetadata>>::sse_decode(deserializer));
3828 } else {
3829 return None;
3830 }
3831 }
3832}
3833
3834impl SseDecode for Option<Vec<crate::bindings::ExternalInputParser>> {
3835 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3837 if (<bool>::sse_decode(deserializer)) {
3838 return Some(<Vec<crate::bindings::ExternalInputParser>>::sse_decode(
3839 deserializer,
3840 ));
3841 } else {
3842 return None;
3843 }
3844 }
3845}
3846
3847impl SseDecode for Option<Vec<crate::model::PaymentState>> {
3848 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3850 if (<bool>::sse_decode(deserializer)) {
3851 return Some(<Vec<crate::model::PaymentState>>::sse_decode(deserializer));
3852 } else {
3853 return None;
3854 }
3855 }
3856}
3857
3858impl SseDecode for Option<Vec<crate::model::PaymentType>> {
3859 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3861 if (<bool>::sse_decode(deserializer)) {
3862 return Some(<Vec<crate::model::PaymentType>>::sse_decode(deserializer));
3863 } else {
3864 return None;
3865 }
3866 }
3867}
3868
3869impl SseDecode for Option<Vec<u8>> {
3870 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3872 if (<bool>::sse_decode(deserializer)) {
3873 return Some(<Vec<u8>>::sse_decode(deserializer));
3874 } else {
3875 return None;
3876 }
3877 }
3878}
3879
3880impl SseDecode for crate::model::PayAmount {
3881 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3883 let mut tag_ = <i32>::sse_decode(deserializer);
3884 match tag_ {
3885 0 => {
3886 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
3887 return crate::model::PayAmount::Bitcoin {
3888 receiver_amount_sat: var_receiverAmountSat,
3889 };
3890 }
3891 1 => {
3892 let mut var_assetId = <String>::sse_decode(deserializer);
3893 let mut var_receiverAmount = <f64>::sse_decode(deserializer);
3894 let mut var_estimateAssetFees = <Option<bool>>::sse_decode(deserializer);
3895 return crate::model::PayAmount::Asset {
3896 asset_id: var_assetId,
3897 receiver_amount: var_receiverAmount,
3898 estimate_asset_fees: var_estimateAssetFees,
3899 };
3900 }
3901 2 => {
3902 return crate::model::PayAmount::Drain;
3903 }
3904 _ => {
3905 unimplemented!("");
3906 }
3907 }
3908 }
3909}
3910
3911impl SseDecode for crate::model::PayOnchainRequest {
3912 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3914 let mut var_address = <String>::sse_decode(deserializer);
3915 let mut var_prepareResponse =
3916 <crate::model::PreparePayOnchainResponse>::sse_decode(deserializer);
3917 return crate::model::PayOnchainRequest {
3918 address: var_address,
3919 prepare_response: var_prepareResponse,
3920 };
3921 }
3922}
3923
3924impl SseDecode for crate::model::Payment {
3925 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3927 let mut var_destination = <Option<String>>::sse_decode(deserializer);
3928 let mut var_txId = <Option<String>>::sse_decode(deserializer);
3929 let mut var_unblindingData = <Option<String>>::sse_decode(deserializer);
3930 let mut var_timestamp = <u32>::sse_decode(deserializer);
3931 let mut var_amountSat = <u64>::sse_decode(deserializer);
3932 let mut var_feesSat = <u64>::sse_decode(deserializer);
3933 let mut var_swapperFeesSat = <Option<u64>>::sse_decode(deserializer);
3934 let mut var_paymentType = <crate::model::PaymentType>::sse_decode(deserializer);
3935 let mut var_status = <crate::model::PaymentState>::sse_decode(deserializer);
3936 let mut var_details = <crate::model::PaymentDetails>::sse_decode(deserializer);
3937 return crate::model::Payment {
3938 destination: var_destination,
3939 tx_id: var_txId,
3940 unblinding_data: var_unblindingData,
3941 timestamp: var_timestamp,
3942 amount_sat: var_amountSat,
3943 fees_sat: var_feesSat,
3944 swapper_fees_sat: var_swapperFeesSat,
3945 payment_type: var_paymentType,
3946 status: var_status,
3947 details: var_details,
3948 };
3949 }
3950}
3951
3952impl SseDecode for crate::model::PaymentDetails {
3953 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3955 let mut tag_ = <i32>::sse_decode(deserializer);
3956 match tag_ {
3957 0 => {
3958 let mut var_swapId = <String>::sse_decode(deserializer);
3959 let mut var_description = <String>::sse_decode(deserializer);
3960 let mut var_liquidExpirationBlockheight = <u32>::sse_decode(deserializer);
3961 let mut var_preimage = <Option<String>>::sse_decode(deserializer);
3962 let mut var_invoice = <Option<String>>::sse_decode(deserializer);
3963 let mut var_bolt12Offer = <Option<String>>::sse_decode(deserializer);
3964 let mut var_paymentHash = <Option<String>>::sse_decode(deserializer);
3965 let mut var_destinationPubkey = <Option<String>>::sse_decode(deserializer);
3966 let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
3967 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
3968 let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
3969 let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
3970 let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
3971 return crate::model::PaymentDetails::Lightning {
3972 swap_id: var_swapId,
3973 description: var_description,
3974 liquid_expiration_blockheight: var_liquidExpirationBlockheight,
3975 preimage: var_preimage,
3976 invoice: var_invoice,
3977 bolt12_offer: var_bolt12Offer,
3978 payment_hash: var_paymentHash,
3979 destination_pubkey: var_destinationPubkey,
3980 lnurl_info: var_lnurlInfo,
3981 bip353_address: var_bip353Address,
3982 claim_tx_id: var_claimTxId,
3983 refund_tx_id: var_refundTxId,
3984 refund_tx_amount_sat: var_refundTxAmountSat,
3985 };
3986 }
3987 1 => {
3988 let mut var_destination = <String>::sse_decode(deserializer);
3989 let mut var_description = <String>::sse_decode(deserializer);
3990 let mut var_assetId = <String>::sse_decode(deserializer);
3991 let mut var_assetInfo = <Option<crate::model::AssetInfo>>::sse_decode(deserializer);
3992 let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
3993 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
3994 return crate::model::PaymentDetails::Liquid {
3995 destination: var_destination,
3996 description: var_description,
3997 asset_id: var_assetId,
3998 asset_info: var_assetInfo,
3999 lnurl_info: var_lnurlInfo,
4000 bip353_address: var_bip353Address,
4001 };
4002 }
4003 2 => {
4004 let mut var_swapId = <String>::sse_decode(deserializer);
4005 let mut var_description = <String>::sse_decode(deserializer);
4006 let mut var_autoAcceptedFees = <bool>::sse_decode(deserializer);
4007 let mut var_liquidExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4008 let mut var_bitcoinExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4009 let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4010 let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4011 let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4012 return crate::model::PaymentDetails::Bitcoin {
4013 swap_id: var_swapId,
4014 description: var_description,
4015 auto_accepted_fees: var_autoAcceptedFees,
4016 liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4017 bitcoin_expiration_blockheight: var_bitcoinExpirationBlockheight,
4018 claim_tx_id: var_claimTxId,
4019 refund_tx_id: var_refundTxId,
4020 refund_tx_amount_sat: var_refundTxAmountSat,
4021 };
4022 }
4023 _ => {
4024 unimplemented!("");
4025 }
4026 }
4027 }
4028}
4029
4030impl SseDecode for crate::error::PaymentError {
4031 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4033 let mut tag_ = <i32>::sse_decode(deserializer);
4034 match tag_ {
4035 0 => {
4036 return crate::error::PaymentError::AlreadyClaimed;
4037 }
4038 1 => {
4039 return crate::error::PaymentError::AlreadyPaid;
4040 }
4041 2 => {
4042 return crate::error::PaymentError::PaymentInProgress;
4043 }
4044 3 => {
4045 return crate::error::PaymentError::AmountOutOfRange;
4046 }
4047 4 => {
4048 let mut var_err = <String>::sse_decode(deserializer);
4049 return crate::error::PaymentError::AmountMissing { err: var_err };
4050 }
4051 5 => {
4052 let mut var_err = <String>::sse_decode(deserializer);
4053 return crate::error::PaymentError::AssetError { err: var_err };
4054 }
4055 6 => {
4056 let mut var_err = <String>::sse_decode(deserializer);
4057 return crate::error::PaymentError::InvalidNetwork { err: var_err };
4058 }
4059 7 => {
4060 let mut var_err = <String>::sse_decode(deserializer);
4061 return crate::error::PaymentError::Generic { err: var_err };
4062 }
4063 8 => {
4064 return crate::error::PaymentError::InvalidOrExpiredFees;
4065 }
4066 9 => {
4067 return crate::error::PaymentError::InsufficientFunds;
4068 }
4069 10 => {
4070 let mut var_err = <String>::sse_decode(deserializer);
4071 return crate::error::PaymentError::InvalidDescription { err: var_err };
4072 }
4073 11 => {
4074 let mut var_err = <String>::sse_decode(deserializer);
4075 return crate::error::PaymentError::InvalidInvoice { err: var_err };
4076 }
4077 12 => {
4078 return crate::error::PaymentError::InvalidPreimage;
4079 }
4080 13 => {
4081 return crate::error::PaymentError::PairsNotFound;
4082 }
4083 14 => {
4084 return crate::error::PaymentError::PaymentTimeout;
4085 }
4086 15 => {
4087 return crate::error::PaymentError::PersistError;
4088 }
4089 16 => {
4090 let mut var_err = <String>::sse_decode(deserializer);
4091 return crate::error::PaymentError::ReceiveError { err: var_err };
4092 }
4093 17 => {
4094 let mut var_err = <String>::sse_decode(deserializer);
4095 let mut var_refundTxId = <String>::sse_decode(deserializer);
4096 return crate::error::PaymentError::Refunded {
4097 err: var_err,
4098 refund_tx_id: var_refundTxId,
4099 };
4100 }
4101 18 => {
4102 return crate::error::PaymentError::SelfTransferNotSupported;
4103 }
4104 19 => {
4105 let mut var_err = <String>::sse_decode(deserializer);
4106 return crate::error::PaymentError::SendError { err: var_err };
4107 }
4108 20 => {
4109 let mut var_err = <String>::sse_decode(deserializer);
4110 return crate::error::PaymentError::SignerError { err: var_err };
4111 }
4112 _ => {
4113 unimplemented!("");
4114 }
4115 }
4116 }
4117}
4118
4119impl SseDecode for crate::model::PaymentMethod {
4120 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4122 let mut inner = <i32>::sse_decode(deserializer);
4123 return match inner {
4124 0 => crate::model::PaymentMethod::Lightning,
4125 1 => crate::model::PaymentMethod::BitcoinAddress,
4126 2 => crate::model::PaymentMethod::LiquidAddress,
4127 _ => unreachable!("Invalid variant for PaymentMethod: {}", inner),
4128 };
4129 }
4130}
4131
4132impl SseDecode for crate::model::PaymentState {
4133 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4135 let mut inner = <i32>::sse_decode(deserializer);
4136 return match inner {
4137 0 => crate::model::PaymentState::Created,
4138 1 => crate::model::PaymentState::Pending,
4139 2 => crate::model::PaymentState::Complete,
4140 3 => crate::model::PaymentState::Failed,
4141 4 => crate::model::PaymentState::TimedOut,
4142 5 => crate::model::PaymentState::Refundable,
4143 6 => crate::model::PaymentState::RefundPending,
4144 7 => crate::model::PaymentState::WaitingFeeAcceptance,
4145 _ => unreachable!("Invalid variant for PaymentState: {}", inner),
4146 };
4147 }
4148}
4149
4150impl SseDecode for crate::model::PaymentType {
4151 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4153 let mut inner = <i32>::sse_decode(deserializer);
4154 return match inner {
4155 0 => crate::model::PaymentType::Receive,
4156 1 => crate::model::PaymentType::Send,
4157 _ => unreachable!("Invalid variant for PaymentType: {}", inner),
4158 };
4159 }
4160}
4161
4162impl SseDecode for crate::model::PrepareBuyBitcoinRequest {
4163 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4165 let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4166 let mut var_amountSat = <u64>::sse_decode(deserializer);
4167 return crate::model::PrepareBuyBitcoinRequest {
4168 provider: var_provider,
4169 amount_sat: var_amountSat,
4170 };
4171 }
4172}
4173
4174impl SseDecode for crate::model::PrepareBuyBitcoinResponse {
4175 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4177 let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4178 let mut var_amountSat = <u64>::sse_decode(deserializer);
4179 let mut var_feesSat = <u64>::sse_decode(deserializer);
4180 return crate::model::PrepareBuyBitcoinResponse {
4181 provider: var_provider,
4182 amount_sat: var_amountSat,
4183 fees_sat: var_feesSat,
4184 };
4185 }
4186}
4187
4188impl SseDecode for crate::model::PrepareLnUrlPayRequest {
4189 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4191 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4192 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4193 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4194 let mut var_comment = <Option<String>>::sse_decode(deserializer);
4195 let mut var_validateSuccessActionUrl = <Option<bool>>::sse_decode(deserializer);
4196 return crate::model::PrepareLnUrlPayRequest {
4197 data: var_data,
4198 amount: var_amount,
4199 bip353_address: var_bip353Address,
4200 comment: var_comment,
4201 validate_success_action_url: var_validateSuccessActionUrl,
4202 };
4203 }
4204}
4205
4206impl SseDecode for crate::model::PrepareLnUrlPayResponse {
4207 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4209 let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4210 let mut var_feesSat = <u64>::sse_decode(deserializer);
4211 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4212 let mut var_comment = <Option<String>>::sse_decode(deserializer);
4213 let mut var_successAction =
4214 <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
4215 return crate::model::PrepareLnUrlPayResponse {
4216 destination: var_destination,
4217 fees_sat: var_feesSat,
4218 data: var_data,
4219 comment: var_comment,
4220 success_action: var_successAction,
4221 };
4222 }
4223}
4224
4225impl SseDecode for crate::model::PreparePayOnchainRequest {
4226 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4228 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4229 let mut var_feeRateSatPerVbyte = <Option<u32>>::sse_decode(deserializer);
4230 return crate::model::PreparePayOnchainRequest {
4231 amount: var_amount,
4232 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4233 };
4234 }
4235}
4236
4237impl SseDecode for crate::model::PreparePayOnchainResponse {
4238 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4240 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4241 let mut var_claimFeesSat = <u64>::sse_decode(deserializer);
4242 let mut var_totalFeesSat = <u64>::sse_decode(deserializer);
4243 return crate::model::PreparePayOnchainResponse {
4244 receiver_amount_sat: var_receiverAmountSat,
4245 claim_fees_sat: var_claimFeesSat,
4246 total_fees_sat: var_totalFeesSat,
4247 };
4248 }
4249}
4250
4251impl SseDecode for crate::model::PrepareReceiveRequest {
4252 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4254 let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4255 let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4256 return crate::model::PrepareReceiveRequest {
4257 payment_method: var_paymentMethod,
4258 amount: var_amount,
4259 };
4260 }
4261}
4262
4263impl SseDecode for crate::model::PrepareReceiveResponse {
4264 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4266 let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4267 let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4268 let mut var_feesSat = <u64>::sse_decode(deserializer);
4269 let mut var_minPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4270 let mut var_maxPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4271 let mut var_swapperFeerate = <Option<f64>>::sse_decode(deserializer);
4272 return crate::model::PrepareReceiveResponse {
4273 payment_method: var_paymentMethod,
4274 amount: var_amount,
4275 fees_sat: var_feesSat,
4276 min_payer_amount_sat: var_minPayerAmountSat,
4277 max_payer_amount_sat: var_maxPayerAmountSat,
4278 swapper_feerate: var_swapperFeerate,
4279 };
4280 }
4281}
4282
4283impl SseDecode for crate::model::PrepareRefundRequest {
4284 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4286 let mut var_swapAddress = <String>::sse_decode(deserializer);
4287 let mut var_refundAddress = <String>::sse_decode(deserializer);
4288 let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4289 return crate::model::PrepareRefundRequest {
4290 swap_address: var_swapAddress,
4291 refund_address: var_refundAddress,
4292 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4293 };
4294 }
4295}
4296
4297impl SseDecode for crate::model::PrepareRefundResponse {
4298 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4300 let mut var_txVsize = <u32>::sse_decode(deserializer);
4301 let mut var_txFeeSat = <u64>::sse_decode(deserializer);
4302 let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4303 return crate::model::PrepareRefundResponse {
4304 tx_vsize: var_txVsize,
4305 tx_fee_sat: var_txFeeSat,
4306 last_refund_tx_id: var_lastRefundTxId,
4307 };
4308 }
4309}
4310
4311impl SseDecode for crate::model::PrepareSendRequest {
4312 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4314 let mut var_destination = <String>::sse_decode(deserializer);
4315 let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4316 return crate::model::PrepareSendRequest {
4317 destination: var_destination,
4318 amount: var_amount,
4319 };
4320 }
4321}
4322
4323impl SseDecode for crate::model::PrepareSendResponse {
4324 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4326 let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4327 let mut var_feesSat = <Option<u64>>::sse_decode(deserializer);
4328 let mut var_estimatedAssetFees = <Option<f64>>::sse_decode(deserializer);
4329 return crate::model::PrepareSendResponse {
4330 destination: var_destination,
4331 fees_sat: var_feesSat,
4332 estimated_asset_fees: var_estimatedAssetFees,
4333 };
4334 }
4335}
4336
4337impl SseDecode for crate::bindings::Rate {
4338 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4340 let mut var_coin = <String>::sse_decode(deserializer);
4341 let mut var_value = <f64>::sse_decode(deserializer);
4342 return crate::bindings::Rate {
4343 coin: var_coin,
4344 value: var_value,
4345 };
4346 }
4347}
4348
4349impl SseDecode for crate::model::ReceiveAmount {
4350 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4352 let mut tag_ = <i32>::sse_decode(deserializer);
4353 match tag_ {
4354 0 => {
4355 let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
4356 return crate::model::ReceiveAmount::Bitcoin {
4357 payer_amount_sat: var_payerAmountSat,
4358 };
4359 }
4360 1 => {
4361 let mut var_assetId = <String>::sse_decode(deserializer);
4362 let mut var_payerAmount = <Option<f64>>::sse_decode(deserializer);
4363 return crate::model::ReceiveAmount::Asset {
4364 asset_id: var_assetId,
4365 payer_amount: var_payerAmount,
4366 };
4367 }
4368 _ => {
4369 unimplemented!("");
4370 }
4371 }
4372 }
4373}
4374
4375impl SseDecode for crate::model::ReceivePaymentRequest {
4376 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4378 let mut var_prepareResponse =
4379 <crate::model::PrepareReceiveResponse>::sse_decode(deserializer);
4380 let mut var_description = <Option<String>>::sse_decode(deserializer);
4381 let mut var_useDescriptionHash = <Option<bool>>::sse_decode(deserializer);
4382 return crate::model::ReceivePaymentRequest {
4383 prepare_response: var_prepareResponse,
4384 description: var_description,
4385 use_description_hash: var_useDescriptionHash,
4386 };
4387 }
4388}
4389
4390impl SseDecode for crate::model::ReceivePaymentResponse {
4391 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4393 let mut var_destination = <String>::sse_decode(deserializer);
4394 return crate::model::ReceivePaymentResponse {
4395 destination: var_destination,
4396 };
4397 }
4398}
4399
4400impl SseDecode for crate::model::RecommendedFees {
4401 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4403 let mut var_fastestFee = <u64>::sse_decode(deserializer);
4404 let mut var_halfHourFee = <u64>::sse_decode(deserializer);
4405 let mut var_hourFee = <u64>::sse_decode(deserializer);
4406 let mut var_economyFee = <u64>::sse_decode(deserializer);
4407 let mut var_minimumFee = <u64>::sse_decode(deserializer);
4408 return crate::model::RecommendedFees {
4409 fastest_fee: var_fastestFee,
4410 half_hour_fee: var_halfHourFee,
4411 hour_fee: var_hourFee,
4412 economy_fee: var_economyFee,
4413 minimum_fee: var_minimumFee,
4414 };
4415 }
4416}
4417
4418impl SseDecode for crate::model::RefundRequest {
4419 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4421 let mut var_swapAddress = <String>::sse_decode(deserializer);
4422 let mut var_refundAddress = <String>::sse_decode(deserializer);
4423 let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4424 return crate::model::RefundRequest {
4425 swap_address: var_swapAddress,
4426 refund_address: var_refundAddress,
4427 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4428 };
4429 }
4430}
4431
4432impl SseDecode for crate::model::RefundResponse {
4433 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4435 let mut var_refundTxId = <String>::sse_decode(deserializer);
4436 return crate::model::RefundResponse {
4437 refund_tx_id: var_refundTxId,
4438 };
4439 }
4440}
4441
4442impl SseDecode for crate::model::RefundableSwap {
4443 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4445 let mut var_swapAddress = <String>::sse_decode(deserializer);
4446 let mut var_timestamp = <u32>::sse_decode(deserializer);
4447 let mut var_amountSat = <u64>::sse_decode(deserializer);
4448 let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4449 return crate::model::RefundableSwap {
4450 swap_address: var_swapAddress,
4451 timestamp: var_timestamp,
4452 amount_sat: var_amountSat,
4453 last_refund_tx_id: var_lastRefundTxId,
4454 };
4455 }
4456}
4457
4458impl SseDecode for crate::model::RestoreRequest {
4459 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4461 let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
4462 return crate::model::RestoreRequest {
4463 backup_path: var_backupPath,
4464 };
4465 }
4466}
4467
4468impl SseDecode for crate::bindings::RouteHint {
4469 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4471 let mut var_hops = <Vec<crate::bindings::RouteHintHop>>::sse_decode(deserializer);
4472 return crate::bindings::RouteHint { hops: var_hops };
4473 }
4474}
4475
4476impl SseDecode for crate::bindings::RouteHintHop {
4477 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4479 let mut var_srcNodeId = <String>::sse_decode(deserializer);
4480 let mut var_shortChannelId = <String>::sse_decode(deserializer);
4481 let mut var_feesBaseMsat = <u32>::sse_decode(deserializer);
4482 let mut var_feesProportionalMillionths = <u32>::sse_decode(deserializer);
4483 let mut var_cltvExpiryDelta = <u64>::sse_decode(deserializer);
4484 let mut var_htlcMinimumMsat = <Option<u64>>::sse_decode(deserializer);
4485 let mut var_htlcMaximumMsat = <Option<u64>>::sse_decode(deserializer);
4486 return crate::bindings::RouteHintHop {
4487 src_node_id: var_srcNodeId,
4488 short_channel_id: var_shortChannelId,
4489 fees_base_msat: var_feesBaseMsat,
4490 fees_proportional_millionths: var_feesProportionalMillionths,
4491 cltv_expiry_delta: var_cltvExpiryDelta,
4492 htlc_minimum_msat: var_htlcMinimumMsat,
4493 htlc_maximum_msat: var_htlcMaximumMsat,
4494 };
4495 }
4496}
4497
4498impl SseDecode for crate::error::SdkError {
4499 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4501 let mut tag_ = <i32>::sse_decode(deserializer);
4502 match tag_ {
4503 0 => {
4504 return crate::error::SdkError::AlreadyStarted;
4505 }
4506 1 => {
4507 let mut var_err = <String>::sse_decode(deserializer);
4508 return crate::error::SdkError::Generic { err: var_err };
4509 }
4510 2 => {
4511 return crate::error::SdkError::NotStarted;
4512 }
4513 3 => {
4514 let mut var_err = <String>::sse_decode(deserializer);
4515 return crate::error::SdkError::ServiceConnectivity { err: var_err };
4516 }
4517 _ => {
4518 unimplemented!("");
4519 }
4520 }
4521 }
4522}
4523
4524impl SseDecode for crate::model::SdkEvent {
4525 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4527 let mut tag_ = <i32>::sse_decode(deserializer);
4528 match tag_ {
4529 0 => {
4530 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4531 return crate::model::SdkEvent::PaymentFailed {
4532 details: var_details,
4533 };
4534 }
4535 1 => {
4536 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4537 return crate::model::SdkEvent::PaymentPending {
4538 details: var_details,
4539 };
4540 }
4541 2 => {
4542 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4543 return crate::model::SdkEvent::PaymentRefundable {
4544 details: var_details,
4545 };
4546 }
4547 3 => {
4548 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4549 return crate::model::SdkEvent::PaymentRefunded {
4550 details: var_details,
4551 };
4552 }
4553 4 => {
4554 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4555 return crate::model::SdkEvent::PaymentRefundPending {
4556 details: var_details,
4557 };
4558 }
4559 5 => {
4560 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4561 return crate::model::SdkEvent::PaymentSucceeded {
4562 details: var_details,
4563 };
4564 }
4565 6 => {
4566 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4567 return crate::model::SdkEvent::PaymentWaitingConfirmation {
4568 details: var_details,
4569 };
4570 }
4571 7 => {
4572 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4573 return crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
4574 details: var_details,
4575 };
4576 }
4577 8 => {
4578 return crate::model::SdkEvent::Synced;
4579 }
4580 9 => {
4581 let mut var_didPullNewRecords = <bool>::sse_decode(deserializer);
4582 return crate::model::SdkEvent::DataSynced {
4583 did_pull_new_records: var_didPullNewRecords,
4584 };
4585 }
4586 _ => {
4587 unimplemented!("");
4588 }
4589 }
4590 }
4591}
4592
4593impl SseDecode for crate::model::SendDestination {
4594 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4596 let mut tag_ = <i32>::sse_decode(deserializer);
4597 match tag_ {
4598 0 => {
4599 let mut var_addressData =
4600 <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
4601 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4602 return crate::model::SendDestination::LiquidAddress {
4603 address_data: var_addressData,
4604 bip353_address: var_bip353Address,
4605 };
4606 }
4607 1 => {
4608 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
4609 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4610 return crate::model::SendDestination::Bolt11 {
4611 invoice: var_invoice,
4612 bip353_address: var_bip353Address,
4613 };
4614 }
4615 2 => {
4616 let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
4617 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4618 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4619 return crate::model::SendDestination::Bolt12 {
4620 offer: var_offer,
4621 receiver_amount_sat: var_receiverAmountSat,
4622 bip353_address: var_bip353Address,
4623 };
4624 }
4625 _ => {
4626 unimplemented!("");
4627 }
4628 }
4629 }
4630}
4631
4632impl SseDecode for crate::model::SendPaymentRequest {
4633 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4635 let mut var_prepareResponse = <crate::model::PrepareSendResponse>::sse_decode(deserializer);
4636 let mut var_useAssetFees = <Option<bool>>::sse_decode(deserializer);
4637 return crate::model::SendPaymentRequest {
4638 prepare_response: var_prepareResponse,
4639 use_asset_fees: var_useAssetFees,
4640 };
4641 }
4642}
4643
4644impl SseDecode for crate::model::SendPaymentResponse {
4645 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4647 let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
4648 return crate::model::SendPaymentResponse {
4649 payment: var_payment,
4650 };
4651 }
4652}
4653
4654impl SseDecode for crate::model::SignMessageRequest {
4655 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4657 let mut var_message = <String>::sse_decode(deserializer);
4658 return crate::model::SignMessageRequest {
4659 message: var_message,
4660 };
4661 }
4662}
4663
4664impl SseDecode for crate::model::SignMessageResponse {
4665 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4667 let mut var_signature = <String>::sse_decode(deserializer);
4668 return crate::model::SignMessageResponse {
4669 signature: var_signature,
4670 };
4671 }
4672}
4673
4674impl SseDecode for crate::bindings::SuccessAction {
4675 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4677 let mut tag_ = <i32>::sse_decode(deserializer);
4678 match tag_ {
4679 0 => {
4680 let mut var_data =
4681 <crate::bindings::AesSuccessActionData>::sse_decode(deserializer);
4682 return crate::bindings::SuccessAction::Aes { data: var_data };
4683 }
4684 1 => {
4685 let mut var_data =
4686 <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4687 return crate::bindings::SuccessAction::Message { data: var_data };
4688 }
4689 2 => {
4690 let mut var_data =
4691 <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4692 return crate::bindings::SuccessAction::Url { data: var_data };
4693 }
4694 _ => {
4695 unimplemented!("");
4696 }
4697 }
4698 }
4699}
4700
4701impl SseDecode for crate::bindings::SuccessActionProcessed {
4702 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4704 let mut tag_ = <i32>::sse_decode(deserializer);
4705 match tag_ {
4706 0 => {
4707 let mut var_result =
4708 <crate::bindings::AesSuccessActionDataResult>::sse_decode(deserializer);
4709 return crate::bindings::SuccessActionProcessed::Aes { result: var_result };
4710 }
4711 1 => {
4712 let mut var_data =
4713 <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4714 return crate::bindings::SuccessActionProcessed::Message { data: var_data };
4715 }
4716 2 => {
4717 let mut var_data =
4718 <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4719 return crate::bindings::SuccessActionProcessed::Url { data: var_data };
4720 }
4721 _ => {
4722 unimplemented!("");
4723 }
4724 }
4725 }
4726}
4727
4728impl SseDecode for crate::bindings::Symbol {
4729 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4731 let mut var_grapheme = <Option<String>>::sse_decode(deserializer);
4732 let mut var_template = <Option<String>>::sse_decode(deserializer);
4733 let mut var_rtl = <Option<bool>>::sse_decode(deserializer);
4734 let mut var_position = <Option<u32>>::sse_decode(deserializer);
4735 return crate::bindings::Symbol {
4736 grapheme: var_grapheme,
4737 template: var_template,
4738 rtl: var_rtl,
4739 position: var_position,
4740 };
4741 }
4742}
4743
4744impl SseDecode for u16 {
4745 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4747 deserializer.cursor.read_u16::<NativeEndian>().unwrap()
4748 }
4749}
4750
4751impl SseDecode for u32 {
4752 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4754 deserializer.cursor.read_u32::<NativeEndian>().unwrap()
4755 }
4756}
4757
4758impl SseDecode for u64 {
4759 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4761 deserializer.cursor.read_u64::<NativeEndian>().unwrap()
4762 }
4763}
4764
4765impl SseDecode for u8 {
4766 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4768 deserializer.cursor.read_u8().unwrap()
4769 }
4770}
4771
4772impl SseDecode for () {
4773 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
4775}
4776
4777impl SseDecode for crate::bindings::UrlSuccessActionData {
4778 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4780 let mut var_description = <String>::sse_decode(deserializer);
4781 let mut var_url = <String>::sse_decode(deserializer);
4782 let mut var_matchesCallbackDomain = <bool>::sse_decode(deserializer);
4783 return crate::bindings::UrlSuccessActionData {
4784 description: var_description,
4785 url: var_url,
4786 matches_callback_domain: var_matchesCallbackDomain,
4787 };
4788 }
4789}
4790
4791impl SseDecode for usize {
4792 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4794 deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
4795 }
4796}
4797
4798impl SseDecode for crate::model::WalletInfo {
4799 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4801 let mut var_balanceSat = <u64>::sse_decode(deserializer);
4802 let mut var_pendingSendSat = <u64>::sse_decode(deserializer);
4803 let mut var_pendingReceiveSat = <u64>::sse_decode(deserializer);
4804 let mut var_fingerprint = <String>::sse_decode(deserializer);
4805 let mut var_pubkey = <String>::sse_decode(deserializer);
4806 let mut var_assetBalances = <Vec<crate::model::AssetBalance>>::sse_decode(deserializer);
4807 return crate::model::WalletInfo {
4808 balance_sat: var_balanceSat,
4809 pending_send_sat: var_pendingSendSat,
4810 pending_receive_sat: var_pendingReceiveSat,
4811 fingerprint: var_fingerprint,
4812 pubkey: var_pubkey,
4813 asset_balances: var_assetBalances,
4814 };
4815 }
4816}
4817
4818fn pde_ffi_dispatcher_primary_impl(
4819 func_id: i32,
4820 port: flutter_rust_bridge::for_generated::MessagePort,
4821 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4822 rust_vec_len: i32,
4823 data_len: i32,
4824) {
4825 match func_id {
4827 _ => unreachable!(),
4828 }
4829}
4830
4831fn pde_ffi_dispatcher_sync_impl(
4832 func_id: i32,
4833 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4834 rust_vec_len: i32,
4835 data_len: i32,
4836) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
4837 match func_id {
4839 _ => unreachable!(),
4840 }
4841}
4842
4843impl flutter_rust_bridge::IntoDart for FrbWrapper<BindingLiquidSdk> {
4847 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4848 flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0)
4849 .into_dart()
4850 }
4851}
4852impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<BindingLiquidSdk> {}
4853
4854impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<BindingLiquidSdk>> for BindingLiquidSdk {
4855 fn into_into_dart(self) -> FrbWrapper<BindingLiquidSdk> {
4856 self.into()
4857 }
4858}
4859
4860impl flutter_rust_bridge::IntoDart for crate::model::AcceptPaymentProposedFeesRequest {
4862 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4863 [self.response.into_into_dart().into_dart()].into_dart()
4864 }
4865}
4866impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4867 for crate::model::AcceptPaymentProposedFeesRequest
4868{
4869}
4870impl flutter_rust_bridge::IntoIntoDart<crate::model::AcceptPaymentProposedFeesRequest>
4871 for crate::model::AcceptPaymentProposedFeesRequest
4872{
4873 fn into_into_dart(self) -> crate::model::AcceptPaymentProposedFeesRequest {
4874 self
4875 }
4876}
4877impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionData> {
4879 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4880 [
4881 self.0.description.into_into_dart().into_dart(),
4882 self.0.ciphertext.into_into_dart().into_dart(),
4883 self.0.iv.into_into_dart().into_dart(),
4884 ]
4885 .into_dart()
4886 }
4887}
4888impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4889 for FrbWrapper<crate::bindings::AesSuccessActionData>
4890{
4891}
4892impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionData>>
4893 for crate::bindings::AesSuccessActionData
4894{
4895 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionData> {
4896 self.into()
4897 }
4898}
4899impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
4901 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4902 [
4903 self.0.description.into_into_dart().into_dart(),
4904 self.0.plaintext.into_into_dart().into_dart(),
4905 ]
4906 .into_dart()
4907 }
4908}
4909impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4910 for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>
4911{
4912}
4913impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>>
4914 for crate::bindings::AesSuccessActionDataDecrypted
4915{
4916 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
4917 self.into()
4918 }
4919}
4920impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
4922 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4923 match self.0 {
4924 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
4925 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
4926 }
4927 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
4928 [1.into_dart(), reason.into_into_dart().into_dart()].into_dart()
4929 }
4930 _ => {
4931 unimplemented!("");
4932 }
4933 }
4934 }
4935}
4936impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4937 for FrbWrapper<crate::bindings::AesSuccessActionDataResult>
4938{
4939}
4940impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataResult>>
4941 for crate::bindings::AesSuccessActionDataResult
4942{
4943 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
4944 self.into()
4945 }
4946}
4947impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Amount> {
4949 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4950 match self.0 {
4951 crate::bindings::Amount::Bitcoin { amount_msat } => {
4952 [0.into_dart(), amount_msat.into_into_dart().into_dart()].into_dart()
4953 }
4954 crate::bindings::Amount::Currency {
4955 iso4217_code,
4956 fractional_amount,
4957 } => [
4958 1.into_dart(),
4959 iso4217_code.into_into_dart().into_dart(),
4960 fractional_amount.into_into_dart().into_dart(),
4961 ]
4962 .into_dart(),
4963 _ => {
4964 unimplemented!("");
4965 }
4966 }
4967 }
4968}
4969impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4970 for FrbWrapper<crate::bindings::Amount>
4971{
4972}
4973impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Amount>>
4974 for crate::bindings::Amount
4975{
4976 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Amount> {
4977 self.into()
4978 }
4979}
4980impl flutter_rust_bridge::IntoDart for crate::model::AssetBalance {
4982 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4983 [
4984 self.asset_id.into_into_dart().into_dart(),
4985 self.balance_sat.into_into_dart().into_dart(),
4986 self.name.into_into_dart().into_dart(),
4987 self.ticker.into_into_dart().into_dart(),
4988 self.balance.into_into_dart().into_dart(),
4989 ]
4990 .into_dart()
4991 }
4992}
4993impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetBalance {}
4994impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetBalance> for crate::model::AssetBalance {
4995 fn into_into_dart(self) -> crate::model::AssetBalance {
4996 self
4997 }
4998}
4999impl flutter_rust_bridge::IntoDart for crate::model::AssetInfo {
5001 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5002 [
5003 self.name.into_into_dart().into_dart(),
5004 self.ticker.into_into_dart().into_dart(),
5005 self.amount.into_into_dart().into_dart(),
5006 self.fees.into_into_dart().into_dart(),
5007 ]
5008 .into_dart()
5009 }
5010}
5011impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetInfo {}
5012impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetInfo> for crate::model::AssetInfo {
5013 fn into_into_dart(self) -> crate::model::AssetInfo {
5014 self
5015 }
5016}
5017impl flutter_rust_bridge::IntoDart for crate::model::AssetMetadata {
5019 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5020 [
5021 self.asset_id.into_into_dart().into_dart(),
5022 self.name.into_into_dart().into_dart(),
5023 self.ticker.into_into_dart().into_dart(),
5024 self.precision.into_into_dart().into_dart(),
5025 self.fiat_id.into_into_dart().into_dart(),
5026 ]
5027 .into_dart()
5028 }
5029}
5030impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetMetadata {}
5031impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetMetadata>
5032 for crate::model::AssetMetadata
5033{
5034 fn into_into_dart(self) -> crate::model::AssetMetadata {
5035 self
5036 }
5037}
5038impl flutter_rust_bridge::IntoDart for crate::model::BackupRequest {
5040 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5041 [self.backup_path.into_into_dart().into_dart()].into_dart()
5042 }
5043}
5044impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BackupRequest {}
5045impl flutter_rust_bridge::IntoIntoDart<crate::model::BackupRequest>
5046 for crate::model::BackupRequest
5047{
5048 fn into_into_dart(self) -> crate::model::BackupRequest {
5049 self
5050 }
5051}
5052impl flutter_rust_bridge::IntoDart for crate::bindings::BindingEventListener {
5054 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5055 [self.stream.into_into_dart().into_dart()].into_dart()
5056 }
5057}
5058impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5059 for crate::bindings::BindingEventListener
5060{
5061}
5062impl flutter_rust_bridge::IntoIntoDart<crate::bindings::BindingEventListener>
5063 for crate::bindings::BindingEventListener
5064{
5065 fn into_into_dart(self) -> crate::bindings::BindingEventListener {
5066 self
5067 }
5068}
5069impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::BitcoinAddressData> {
5071 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5072 [
5073 self.0.address.into_into_dart().into_dart(),
5074 self.0.network.into_into_dart().into_dart(),
5075 self.0.amount_sat.into_into_dart().into_dart(),
5076 self.0.label.into_into_dart().into_dart(),
5077 self.0.message.into_into_dart().into_dart(),
5078 ]
5079 .into_dart()
5080 }
5081}
5082impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5083 for FrbWrapper<crate::bindings::BitcoinAddressData>
5084{
5085}
5086impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::BitcoinAddressData>>
5087 for crate::bindings::BitcoinAddressData
5088{
5089 fn into_into_dart(self) -> FrbWrapper<crate::bindings::BitcoinAddressData> {
5090 self.into()
5091 }
5092}
5093impl flutter_rust_bridge::IntoDart for crate::model::BlockchainExplorer {
5095 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5096 match self {
5097 crate::model::BlockchainExplorer::Electrum { url } => {
5098 [0.into_dart(), url.into_into_dart().into_dart()].into_dart()
5099 }
5100 crate::model::BlockchainExplorer::Esplora {
5101 url,
5102 use_waterfalls,
5103 } => [
5104 1.into_dart(),
5105 url.into_into_dart().into_dart(),
5106 use_waterfalls.into_into_dart().into_dart(),
5107 ]
5108 .into_dart(),
5109 _ => {
5110 unimplemented!("");
5111 }
5112 }
5113 }
5114}
5115impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5116 for crate::model::BlockchainExplorer
5117{
5118}
5119impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainExplorer>
5120 for crate::model::BlockchainExplorer
5121{
5122 fn into_into_dart(self) -> crate::model::BlockchainExplorer {
5123 self
5124 }
5125}
5126impl flutter_rust_bridge::IntoDart for crate::model::BlockchainInfo {
5128 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5129 [
5130 self.liquid_tip.into_into_dart().into_dart(),
5131 self.bitcoin_tip.into_into_dart().into_dart(),
5132 ]
5133 .into_dart()
5134 }
5135}
5136impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BlockchainInfo {}
5137impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainInfo>
5138 for crate::model::BlockchainInfo
5139{
5140 fn into_into_dart(self) -> crate::model::BlockchainInfo {
5141 self
5142 }
5143}
5144impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinProvider {
5146 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5147 match self {
5148 Self::Moonpay => 0.into_dart(),
5149 _ => unreachable!(),
5150 }
5151 }
5152}
5153impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5154 for crate::model::BuyBitcoinProvider
5155{
5156}
5157impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinProvider>
5158 for crate::model::BuyBitcoinProvider
5159{
5160 fn into_into_dart(self) -> crate::model::BuyBitcoinProvider {
5161 self
5162 }
5163}
5164impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinRequest {
5166 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5167 [
5168 self.prepare_response.into_into_dart().into_dart(),
5169 self.redirect_url.into_into_dart().into_dart(),
5170 ]
5171 .into_dart()
5172 }
5173}
5174impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5175 for crate::model::BuyBitcoinRequest
5176{
5177}
5178impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinRequest>
5179 for crate::model::BuyBitcoinRequest
5180{
5181 fn into_into_dart(self) -> crate::model::BuyBitcoinRequest {
5182 self
5183 }
5184}
5185impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageRequest {
5187 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5188 [
5189 self.message.into_into_dart().into_dart(),
5190 self.pubkey.into_into_dart().into_dart(),
5191 self.signature.into_into_dart().into_dart(),
5192 ]
5193 .into_dart()
5194 }
5195}
5196impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5197 for crate::model::CheckMessageRequest
5198{
5199}
5200impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageRequest>
5201 for crate::model::CheckMessageRequest
5202{
5203 fn into_into_dart(self) -> crate::model::CheckMessageRequest {
5204 self
5205 }
5206}
5207impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageResponse {
5209 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5210 [self.is_valid.into_into_dart().into_dart()].into_dart()
5211 }
5212}
5213impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5214 for crate::model::CheckMessageResponse
5215{
5216}
5217impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageResponse>
5218 for crate::model::CheckMessageResponse
5219{
5220 fn into_into_dart(self) -> crate::model::CheckMessageResponse {
5221 self
5222 }
5223}
5224impl flutter_rust_bridge::IntoDart for crate::model::Config {
5226 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5227 [
5228 self.liquid_explorer.into_into_dart().into_dart(),
5229 self.bitcoin_explorer.into_into_dart().into_dart(),
5230 self.working_dir.into_into_dart().into_dart(),
5231 self.cache_dir.into_into_dart().into_dart(),
5232 self.network.into_into_dart().into_dart(),
5233 self.payment_timeout_sec.into_into_dart().into_dart(),
5234 self.sync_service_url.into_into_dart().into_dart(),
5235 self.zero_conf_max_amount_sat.into_into_dart().into_dart(),
5236 self.breez_api_key.into_into_dart().into_dart(),
5237 self.external_input_parsers.into_into_dart().into_dart(),
5238 self.use_default_external_input_parsers
5239 .into_into_dart()
5240 .into_dart(),
5241 self.onchain_fee_rate_leeway_sat_per_vbyte
5242 .into_into_dart()
5243 .into_dart(),
5244 self.asset_metadata.into_into_dart().into_dart(),
5245 self.sideswap_api_key.into_into_dart().into_dart(),
5246 ]
5247 .into_dart()
5248 }
5249}
5250impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Config {}
5251impl flutter_rust_bridge::IntoIntoDart<crate::model::Config> for crate::model::Config {
5252 fn into_into_dart(self) -> crate::model::Config {
5253 self
5254 }
5255}
5256impl flutter_rust_bridge::IntoDart for crate::model::ConnectRequest {
5258 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5259 [
5260 self.config.into_into_dart().into_dart(),
5261 self.mnemonic.into_into_dart().into_dart(),
5262 self.passphrase.into_into_dart().into_dart(),
5263 self.seed.into_into_dart().into_dart(),
5264 ]
5265 .into_dart()
5266 }
5267}
5268impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ConnectRequest {}
5269impl flutter_rust_bridge::IntoIntoDart<crate::model::ConnectRequest>
5270 for crate::model::ConnectRequest
5271{
5272 fn into_into_dart(self) -> crate::model::ConnectRequest {
5273 self
5274 }
5275}
5276impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::CurrencyInfo> {
5278 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5279 [
5280 self.0.name.into_into_dart().into_dart(),
5281 self.0.fraction_size.into_into_dart().into_dart(),
5282 self.0.spacing.into_into_dart().into_dart(),
5283 self.0.symbol.into_into_dart().into_dart(),
5284 self.0.uniq_symbol.into_into_dart().into_dart(),
5285 self.0.localized_name.into_into_dart().into_dart(),
5286 self.0.locale_overrides.into_into_dart().into_dart(),
5287 ]
5288 .into_dart()
5289 }
5290}
5291impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5292 for FrbWrapper<crate::bindings::CurrencyInfo>
5293{
5294}
5295impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::CurrencyInfo>>
5296 for crate::bindings::CurrencyInfo
5297{
5298 fn into_into_dart(self) -> FrbWrapper<crate::bindings::CurrencyInfo> {
5299 self.into()
5300 }
5301}
5302impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::ExternalInputParser> {
5304 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5305 [
5306 self.0.provider_id.into_into_dart().into_dart(),
5307 self.0.input_regex.into_into_dart().into_dart(),
5308 self.0.parser_url.into_into_dart().into_dart(),
5309 ]
5310 .into_dart()
5311 }
5312}
5313impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5314 for FrbWrapper<crate::bindings::ExternalInputParser>
5315{
5316}
5317impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::ExternalInputParser>>
5318 for crate::bindings::ExternalInputParser
5319{
5320 fn into_into_dart(self) -> FrbWrapper<crate::bindings::ExternalInputParser> {
5321 self.into()
5322 }
5323}
5324impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesRequest {
5326 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5327 [self.swap_id.into_into_dart().into_dart()].into_dart()
5328 }
5329}
5330impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5331 for crate::model::FetchPaymentProposedFeesRequest
5332{
5333}
5334impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesRequest>
5335 for crate::model::FetchPaymentProposedFeesRequest
5336{
5337 fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesRequest {
5338 self
5339 }
5340}
5341impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesResponse {
5343 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5344 [
5345 self.swap_id.into_into_dart().into_dart(),
5346 self.fees_sat.into_into_dart().into_dart(),
5347 self.payer_amount_sat.into_into_dart().into_dart(),
5348 self.receiver_amount_sat.into_into_dart().into_dart(),
5349 ]
5350 .into_dart()
5351 }
5352}
5353impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5354 for crate::model::FetchPaymentProposedFeesResponse
5355{
5356}
5357impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesResponse>
5358 for crate::model::FetchPaymentProposedFeesResponse
5359{
5360 fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesResponse {
5361 self
5362 }
5363}
5364impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::FiatCurrency> {
5366 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5367 [
5368 self.0.id.into_into_dart().into_dart(),
5369 self.0.info.into_into_dart().into_dart(),
5370 ]
5371 .into_dart()
5372 }
5373}
5374impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5375 for FrbWrapper<crate::bindings::FiatCurrency>
5376{
5377}
5378impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::FiatCurrency>>
5379 for crate::bindings::FiatCurrency
5380{
5381 fn into_into_dart(self) -> FrbWrapper<crate::bindings::FiatCurrency> {
5382 self.into()
5383 }
5384}
5385impl flutter_rust_bridge::IntoDart for crate::model::GetInfoResponse {
5387 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5388 [
5389 self.wallet_info.into_into_dart().into_dart(),
5390 self.blockchain_info.into_into_dart().into_dart(),
5391 ]
5392 .into_dart()
5393 }
5394}
5395impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::GetInfoResponse {}
5396impl flutter_rust_bridge::IntoIntoDart<crate::model::GetInfoResponse>
5397 for crate::model::GetInfoResponse
5398{
5399 fn into_into_dart(self) -> crate::model::GetInfoResponse {
5400 self
5401 }
5402}
5403impl flutter_rust_bridge::IntoDart for crate::model::GetPaymentRequest {
5405 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5406 match self {
5407 crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
5408 [0.into_dart(), payment_hash.into_into_dart().into_dart()].into_dart()
5409 }
5410 crate::model::GetPaymentRequest::SwapId { swap_id } => {
5411 [1.into_dart(), swap_id.into_into_dart().into_dart()].into_dart()
5412 }
5413 _ => {
5414 unimplemented!("");
5415 }
5416 }
5417 }
5418}
5419impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5420 for crate::model::GetPaymentRequest
5421{
5422}
5423impl flutter_rust_bridge::IntoIntoDart<crate::model::GetPaymentRequest>
5424 for crate::model::GetPaymentRequest
5425{
5426 fn into_into_dart(self) -> crate::model::GetPaymentRequest {
5427 self
5428 }
5429}
5430impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::InputType> {
5432 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5433 match self.0 {
5434 crate::bindings::InputType::BitcoinAddress { address } => {
5435 [0.into_dart(), address.into_into_dart().into_dart()].into_dart()
5436 }
5437 crate::bindings::InputType::LiquidAddress { address } => {
5438 [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5439 }
5440 crate::bindings::InputType::Bolt11 { invoice } => {
5441 [2.into_dart(), invoice.into_into_dart().into_dart()].into_dart()
5442 }
5443 crate::bindings::InputType::Bolt12Offer {
5444 offer,
5445 bip353_address,
5446 } => [
5447 3.into_dart(),
5448 offer.into_into_dart().into_dart(),
5449 bip353_address.into_into_dart().into_dart(),
5450 ]
5451 .into_dart(),
5452 crate::bindings::InputType::NodeId { node_id } => {
5453 [4.into_dart(), node_id.into_into_dart().into_dart()].into_dart()
5454 }
5455 crate::bindings::InputType::Url { url } => {
5456 [5.into_dart(), url.into_into_dart().into_dart()].into_dart()
5457 }
5458 crate::bindings::InputType::LnUrlPay {
5459 data,
5460 bip353_address,
5461 } => [
5462 6.into_dart(),
5463 data.into_into_dart().into_dart(),
5464 bip353_address.into_into_dart().into_dart(),
5465 ]
5466 .into_dart(),
5467 crate::bindings::InputType::LnUrlWithdraw { data } => {
5468 [7.into_dart(), data.into_into_dart().into_dart()].into_dart()
5469 }
5470 crate::bindings::InputType::LnUrlAuth { data } => {
5471 [8.into_dart(), data.into_into_dart().into_dart()].into_dart()
5472 }
5473 crate::bindings::InputType::LnUrlError { data } => {
5474 [9.into_dart(), data.into_into_dart().into_dart()].into_dart()
5475 }
5476 _ => {
5477 unimplemented!("");
5478 }
5479 }
5480 }
5481}
5482impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5483 for FrbWrapper<crate::bindings::InputType>
5484{
5485}
5486impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::InputType>>
5487 for crate::bindings::InputType
5488{
5489 fn into_into_dart(self) -> FrbWrapper<crate::bindings::InputType> {
5490 self.into()
5491 }
5492}
5493impl flutter_rust_bridge::IntoDart for crate::model::LightningPaymentLimitsResponse {
5495 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5496 [
5497 self.send.into_into_dart().into_dart(),
5498 self.receive.into_into_dart().into_dart(),
5499 ]
5500 .into_dart()
5501 }
5502}
5503impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5504 for crate::model::LightningPaymentLimitsResponse
5505{
5506}
5507impl flutter_rust_bridge::IntoIntoDart<crate::model::LightningPaymentLimitsResponse>
5508 for crate::model::LightningPaymentLimitsResponse
5509{
5510 fn into_into_dart(self) -> crate::model::LightningPaymentLimitsResponse {
5511 self
5512 }
5513}
5514impl flutter_rust_bridge::IntoDart for crate::model::Limits {
5516 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5517 [
5518 self.min_sat.into_into_dart().into_dart(),
5519 self.max_sat.into_into_dart().into_dart(),
5520 self.max_zero_conf_sat.into_into_dart().into_dart(),
5521 ]
5522 .into_dart()
5523 }
5524}
5525impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Limits {}
5526impl flutter_rust_bridge::IntoIntoDart<crate::model::Limits> for crate::model::Limits {
5527 fn into_into_dart(self) -> crate::model::Limits {
5528 self
5529 }
5530}
5531impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LiquidAddressData> {
5533 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5534 [
5535 self.0.address.into_into_dart().into_dart(),
5536 self.0.network.into_into_dart().into_dart(),
5537 self.0.asset_id.into_into_dart().into_dart(),
5538 self.0.amount.into_into_dart().into_dart(),
5539 self.0.amount_sat.into_into_dart().into_dart(),
5540 self.0.label.into_into_dart().into_dart(),
5541 self.0.message.into_into_dart().into_dart(),
5542 ]
5543 .into_dart()
5544 }
5545}
5546impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5547 for FrbWrapper<crate::bindings::LiquidAddressData>
5548{
5549}
5550impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LiquidAddressData>>
5551 for crate::bindings::LiquidAddressData
5552{
5553 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LiquidAddressData> {
5554 self.into()
5555 }
5556}
5557impl flutter_rust_bridge::IntoDart for crate::model::LiquidNetwork {
5559 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5560 match self {
5561 Self::Mainnet => 0.into_dart(),
5562 Self::Testnet => 1.into_dart(),
5563 Self::Regtest => 2.into_dart(),
5564 _ => unreachable!(),
5565 }
5566 }
5567}
5568impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LiquidNetwork {}
5569impl flutter_rust_bridge::IntoIntoDart<crate::model::LiquidNetwork>
5570 for crate::model::LiquidNetwork
5571{
5572 fn into_into_dart(self) -> crate::model::LiquidNetwork {
5573 self
5574 }
5575}
5576impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentDetails {
5578 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5579 match self {
5580 crate::model::ListPaymentDetails::Liquid {
5581 asset_id,
5582 destination,
5583 } => [
5584 0.into_dart(),
5585 asset_id.into_into_dart().into_dart(),
5586 destination.into_into_dart().into_dart(),
5587 ]
5588 .into_dart(),
5589 crate::model::ListPaymentDetails::Bitcoin { address } => {
5590 [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5591 }
5592 _ => {
5593 unimplemented!("");
5594 }
5595 }
5596 }
5597}
5598impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5599 for crate::model::ListPaymentDetails
5600{
5601}
5602impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentDetails>
5603 for crate::model::ListPaymentDetails
5604{
5605 fn into_into_dart(self) -> crate::model::ListPaymentDetails {
5606 self
5607 }
5608}
5609impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentsRequest {
5611 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5612 [
5613 self.filters.into_into_dart().into_dart(),
5614 self.states.into_into_dart().into_dart(),
5615 self.from_timestamp.into_into_dart().into_dart(),
5616 self.to_timestamp.into_into_dart().into_dart(),
5617 self.offset.into_into_dart().into_dart(),
5618 self.limit.into_into_dart().into_dart(),
5619 self.details.into_into_dart().into_dart(),
5620 self.sort_ascending.into_into_dart().into_dart(),
5621 ]
5622 .into_dart()
5623 }
5624}
5625impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5626 for crate::model::ListPaymentsRequest
5627{
5628}
5629impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentsRequest>
5630 for crate::model::ListPaymentsRequest
5631{
5632 fn into_into_dart(self) -> crate::model::ListPaymentsRequest {
5633 self
5634 }
5635}
5636impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNInvoice> {
5638 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5639 [
5640 self.0.bolt11.into_into_dart().into_dart(),
5641 self.0.network.into_into_dart().into_dart(),
5642 self.0.payee_pubkey.into_into_dart().into_dart(),
5643 self.0.payment_hash.into_into_dart().into_dart(),
5644 self.0.description.into_into_dart().into_dart(),
5645 self.0.description_hash.into_into_dart().into_dart(),
5646 self.0.amount_msat.into_into_dart().into_dart(),
5647 self.0.timestamp.into_into_dart().into_dart(),
5648 self.0.expiry.into_into_dart().into_dart(),
5649 self.0.routing_hints.into_into_dart().into_dart(),
5650 self.0.payment_secret.into_into_dart().into_dart(),
5651 self.0
5652 .min_final_cltv_expiry_delta
5653 .into_into_dart()
5654 .into_dart(),
5655 ]
5656 .into_dart()
5657 }
5658}
5659impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5660 for FrbWrapper<crate::bindings::LNInvoice>
5661{
5662}
5663impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNInvoice>>
5664 for crate::bindings::LNInvoice
5665{
5666 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNInvoice> {
5667 self.into()
5668 }
5669}
5670impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNOffer> {
5672 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5673 [
5674 self.0.offer.into_into_dart().into_dart(),
5675 self.0.chains.into_into_dart().into_dart(),
5676 self.0.min_amount.into_into_dart().into_dart(),
5677 self.0.description.into_into_dart().into_dart(),
5678 self.0.absolute_expiry.into_into_dart().into_dart(),
5679 self.0.issuer.into_into_dart().into_dart(),
5680 self.0.signing_pubkey.into_into_dart().into_dart(),
5681 self.0.paths.into_into_dart().into_dart(),
5682 ]
5683 .into_dart()
5684 }
5685}
5686impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5687 for FrbWrapper<crate::bindings::LNOffer>
5688{
5689}
5690impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNOffer>>
5691 for crate::bindings::LNOffer
5692{
5693 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNOffer> {
5694 self.into()
5695 }
5696}
5697impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5699 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5700 [self.0.blinded_hops.into_into_dart().into_dart()].into_dart()
5701 }
5702}
5703impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5704 for FrbWrapper<crate::bindings::LnOfferBlindedPath>
5705{
5706}
5707impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnOfferBlindedPath>>
5708 for crate::bindings::LnOfferBlindedPath
5709{
5710 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5711 self.into()
5712 }
5713}
5714impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlAuthError {
5716 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5717 match self {
5718 crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
5719 [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
5720 }
5721 crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
5722 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5723 }
5724 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
5725 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5726 }
5727 _ => {
5728 unimplemented!("");
5729 }
5730 }
5731 }
5732}
5733impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5734 for crate::bindings::duplicates::LnUrlAuthError
5735{
5736}
5737impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlAuthError>
5738 for crate::bindings::duplicates::LnUrlAuthError
5739{
5740 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlAuthError {
5741 self
5742 }
5743}
5744impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5746 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5747 [
5748 self.0.k1.into_into_dart().into_dart(),
5749 self.0.action.into_into_dart().into_dart(),
5750 self.0.domain.into_into_dart().into_dart(),
5751 self.0.url.into_into_dart().into_dart(),
5752 ]
5753 .into_dart()
5754 }
5755}
5756impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5757 for FrbWrapper<crate::bindings::LnUrlAuthRequestData>
5758{
5759}
5760impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlAuthRequestData>>
5761 for crate::bindings::LnUrlAuthRequestData
5762{
5763 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5764 self.into()
5765 }
5766}
5767impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlCallbackStatus {
5769 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5770 match self {
5771 crate::bindings::duplicates::LnUrlCallbackStatus::Ok => [0.into_dart()].into_dart(),
5772 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
5773 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
5774 }
5775 _ => {
5776 unimplemented!("");
5777 }
5778 }
5779 }
5780}
5781impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5782 for crate::bindings::duplicates::LnUrlCallbackStatus
5783{
5784}
5785impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlCallbackStatus>
5786 for crate::bindings::duplicates::LnUrlCallbackStatus
5787{
5788 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
5789 self
5790 }
5791}
5792impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlErrorData> {
5794 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5795 [self.0.reason.into_into_dart().into_dart()].into_dart()
5796 }
5797}
5798impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5799 for FrbWrapper<crate::bindings::LnUrlErrorData>
5800{
5801}
5802impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlErrorData>>
5803 for crate::bindings::LnUrlErrorData
5804{
5805 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlErrorData> {
5806 self.into()
5807 }
5808}
5809impl flutter_rust_bridge::IntoDart for crate::model::LnUrlInfo {
5811 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5812 [
5813 self.ln_address.into_into_dart().into_dart(),
5814 self.lnurl_pay_comment.into_into_dart().into_dart(),
5815 self.lnurl_pay_domain.into_into_dart().into_dart(),
5816 self.lnurl_pay_metadata.into_into_dart().into_dart(),
5817 self.lnurl_pay_success_action.into_into_dart().into_dart(),
5818 self.lnurl_pay_unprocessed_success_action
5819 .into_into_dart()
5820 .into_dart(),
5821 self.lnurl_withdraw_endpoint.into_into_dart().into_dart(),
5822 ]
5823 .into_dart()
5824 }
5825}
5826impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlInfo {}
5827impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlInfo> for crate::model::LnUrlInfo {
5828 fn into_into_dart(self) -> crate::model::LnUrlInfo {
5829 self
5830 }
5831}
5832impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlPayError {
5834 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5835 match self {
5836 crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => [0.into_dart()].into_dart(),
5837 crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
5838 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5839 }
5840 crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
5841 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5842 }
5843 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
5844 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
5845 }
5846 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
5847 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
5848 }
5849 crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
5850 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
5851 }
5852 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
5853 [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
5854 }
5855 crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
5856 [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
5857 }
5858 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
5859 [8.into_dart(), err.into_into_dart().into_dart()].into_dart()
5860 }
5861 crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
5862 [9.into_dart(), err.into_into_dart().into_dart()].into_dart()
5863 }
5864 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
5865 [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
5866 }
5867 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
5868 [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
5869 }
5870 _ => {
5871 unimplemented!("");
5872 }
5873 }
5874 }
5875}
5876impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5877 for crate::bindings::duplicates::LnUrlPayError
5878{
5879}
5880impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlPayError>
5881 for crate::bindings::duplicates::LnUrlPayError
5882{
5883 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlPayError {
5884 self
5885 }
5886}
5887impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayErrorData> {
5889 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5890 [
5891 self.0.payment_hash.into_into_dart().into_dart(),
5892 self.0.reason.into_into_dart().into_dart(),
5893 ]
5894 .into_dart()
5895 }
5896}
5897impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5898 for FrbWrapper<crate::bindings::LnUrlPayErrorData>
5899{
5900}
5901impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayErrorData>>
5902 for crate::bindings::LnUrlPayErrorData
5903{
5904 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayErrorData> {
5905 self.into()
5906 }
5907}
5908impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayRequest {
5910 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5911 [self.prepare_response.into_into_dart().into_dart()].into_dart()
5912 }
5913}
5914impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayRequest {}
5915impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayRequest>
5916 for crate::model::LnUrlPayRequest
5917{
5918 fn into_into_dart(self) -> crate::model::LnUrlPayRequest {
5919 self
5920 }
5921}
5922impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayRequestData> {
5924 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5925 [
5926 self.0.callback.into_into_dart().into_dart(),
5927 self.0.min_sendable.into_into_dart().into_dart(),
5928 self.0.max_sendable.into_into_dart().into_dart(),
5929 self.0.metadata_str.into_into_dart().into_dart(),
5930 self.0.comment_allowed.into_into_dart().into_dart(),
5931 self.0.domain.into_into_dart().into_dart(),
5932 self.0.allows_nostr.into_into_dart().into_dart(),
5933 self.0.nostr_pubkey.into_into_dart().into_dart(),
5934 self.0.ln_address.into_into_dart().into_dart(),
5935 ]
5936 .into_dart()
5937 }
5938}
5939impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5940 for FrbWrapper<crate::bindings::LnUrlPayRequestData>
5941{
5942}
5943impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayRequestData>>
5944 for crate::bindings::LnUrlPayRequestData
5945{
5946 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayRequestData> {
5947 self.into()
5948 }
5949}
5950impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayResult {
5952 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5953 match self {
5954 crate::model::LnUrlPayResult::EndpointSuccess { data } => {
5955 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
5956 }
5957 crate::model::LnUrlPayResult::EndpointError { data } => {
5958 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
5959 }
5960 crate::model::LnUrlPayResult::PayError { data } => {
5961 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
5962 }
5963 _ => {
5964 unimplemented!("");
5965 }
5966 }
5967 }
5968}
5969impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayResult {}
5970impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayResult>
5971 for crate::model::LnUrlPayResult
5972{
5973 fn into_into_dart(self) -> crate::model::LnUrlPayResult {
5974 self
5975 }
5976}
5977impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPaySuccessData {
5979 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5980 [
5981 self.payment.into_into_dart().into_dart(),
5982 self.success_action.into_into_dart().into_dart(),
5983 ]
5984 .into_dart()
5985 }
5986}
5987impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5988 for crate::model::LnUrlPaySuccessData
5989{
5990}
5991impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPaySuccessData>
5992 for crate::model::LnUrlPaySuccessData
5993{
5994 fn into_into_dart(self) -> crate::model::LnUrlPaySuccessData {
5995 self
5996 }
5997}
5998impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawError {
6000 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6001 match self {
6002 crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
6003 [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
6004 }
6005 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
6006 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
6007 }
6008 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
6009 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
6010 }
6011 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
6012 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
6013 }
6014 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
6015 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6016 }
6017 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
6018 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6019 }
6020 _ => {
6021 unimplemented!("");
6022 }
6023 }
6024 }
6025}
6026impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6027 for crate::bindings::duplicates::LnUrlWithdrawError
6028{
6029}
6030impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawError>
6031 for crate::bindings::duplicates::LnUrlWithdrawError
6032{
6033 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
6034 self
6035 }
6036}
6037impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6039 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6040 [
6041 self.0.data.into_into_dart().into_dart(),
6042 self.0.amount_msat.into_into_dart().into_dart(),
6043 self.0.description.into_into_dart().into_dart(),
6044 ]
6045 .into_dart()
6046 }
6047}
6048impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6049 for FrbWrapper<crate::bindings::LnUrlWithdrawRequest>
6050{
6051}
6052impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequest>>
6053 for crate::bindings::LnUrlWithdrawRequest
6054{
6055 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6056 self.into()
6057 }
6058}
6059impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6061 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6062 [
6063 self.0.callback.into_into_dart().into_dart(),
6064 self.0.k1.into_into_dart().into_dart(),
6065 self.0.default_description.into_into_dart().into_dart(),
6066 self.0.min_withdrawable.into_into_dart().into_dart(),
6067 self.0.max_withdrawable.into_into_dart().into_dart(),
6068 ]
6069 .into_dart()
6070 }
6071}
6072impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6073 for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>
6074{
6075}
6076impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>>
6077 for crate::bindings::LnUrlWithdrawRequestData
6078{
6079 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6080 self.into()
6081 }
6082}
6083impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawResult {
6085 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6086 match self {
6087 crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
6088 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6089 }
6090 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
6091 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6092 }
6093 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
6094 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6095 }
6096 _ => {
6097 unimplemented!("");
6098 }
6099 }
6100 }
6101}
6102impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6103 for crate::bindings::duplicates::LnUrlWithdrawResult
6104{
6105}
6106impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawResult>
6107 for crate::bindings::duplicates::LnUrlWithdrawResult
6108{
6109 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
6110 self
6111 }
6112}
6113impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6115 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6116 [self.invoice.into_into_dart().into_dart()].into_dart()
6117 }
6118}
6119impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6120 for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6121{
6122}
6123impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
6124 for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6125{
6126 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6127 self
6128 }
6129}
6130impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocaleOverrides> {
6132 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6133 [
6134 self.0.locale.into_into_dart().into_dart(),
6135 self.0.spacing.into_into_dart().into_dart(),
6136 self.0.symbol.into_into_dart().into_dart(),
6137 ]
6138 .into_dart()
6139 }
6140}
6141impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6142 for FrbWrapper<crate::bindings::LocaleOverrides>
6143{
6144}
6145impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocaleOverrides>>
6146 for crate::bindings::LocaleOverrides
6147{
6148 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocaleOverrides> {
6149 self.into()
6150 }
6151}
6152impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocalizedName> {
6154 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6155 [
6156 self.0.locale.into_into_dart().into_dart(),
6157 self.0.name.into_into_dart().into_dart(),
6158 ]
6159 .into_dart()
6160 }
6161}
6162impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6163 for FrbWrapper<crate::bindings::LocalizedName>
6164{
6165}
6166impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocalizedName>>
6167 for crate::bindings::LocalizedName
6168{
6169 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocalizedName> {
6170 self.into()
6171 }
6172}
6173impl flutter_rust_bridge::IntoDart for crate::model::LogEntry {
6175 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6176 [
6177 self.line.into_into_dart().into_dart(),
6178 self.level.into_into_dart().into_dart(),
6179 ]
6180 .into_dart()
6181 }
6182}
6183impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LogEntry {}
6184impl flutter_rust_bridge::IntoIntoDart<crate::model::LogEntry> for crate::model::LogEntry {
6185 fn into_into_dart(self) -> crate::model::LogEntry {
6186 self
6187 }
6188}
6189impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::MessageSuccessActionData> {
6191 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6192 [self.0.message.into_into_dart().into_dart()].into_dart()
6193 }
6194}
6195impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6196 for FrbWrapper<crate::bindings::MessageSuccessActionData>
6197{
6198}
6199impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::MessageSuccessActionData>>
6200 for crate::bindings::MessageSuccessActionData
6201{
6202 fn into_into_dart(self) -> FrbWrapper<crate::bindings::MessageSuccessActionData> {
6203 self.into()
6204 }
6205}
6206impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Network> {
6208 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6209 match self.0 {
6210 crate::bindings::Network::Bitcoin => 0.into_dart(),
6211 crate::bindings::Network::Testnet => 1.into_dart(),
6212 crate::bindings::Network::Signet => 2.into_dart(),
6213 crate::bindings::Network::Regtest => 3.into_dart(),
6214 _ => unreachable!(),
6215 }
6216 }
6217}
6218impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6219 for FrbWrapper<crate::bindings::Network>
6220{
6221}
6222impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Network>>
6223 for crate::bindings::Network
6224{
6225 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Network> {
6226 self.into()
6227 }
6228}
6229impl flutter_rust_bridge::IntoDart for crate::model::OnchainPaymentLimitsResponse {
6231 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6232 [
6233 self.send.into_into_dart().into_dart(),
6234 self.receive.into_into_dart().into_dart(),
6235 ]
6236 .into_dart()
6237 }
6238}
6239impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6240 for crate::model::OnchainPaymentLimitsResponse
6241{
6242}
6243impl flutter_rust_bridge::IntoIntoDart<crate::model::OnchainPaymentLimitsResponse>
6244 for crate::model::OnchainPaymentLimitsResponse
6245{
6246 fn into_into_dart(self) -> crate::model::OnchainPaymentLimitsResponse {
6247 self
6248 }
6249}
6250impl flutter_rust_bridge::IntoDart for crate::model::PayAmount {
6252 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6253 match self {
6254 crate::model::PayAmount::Bitcoin {
6255 receiver_amount_sat,
6256 } => [
6257 0.into_dart(),
6258 receiver_amount_sat.into_into_dart().into_dart(),
6259 ]
6260 .into_dart(),
6261 crate::model::PayAmount::Asset {
6262 asset_id,
6263 receiver_amount,
6264 estimate_asset_fees,
6265 } => [
6266 1.into_dart(),
6267 asset_id.into_into_dart().into_dart(),
6268 receiver_amount.into_into_dart().into_dart(),
6269 estimate_asset_fees.into_into_dart().into_dart(),
6270 ]
6271 .into_dart(),
6272 crate::model::PayAmount::Drain => [2.into_dart()].into_dart(),
6273 _ => {
6274 unimplemented!("");
6275 }
6276 }
6277 }
6278}
6279impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PayAmount {}
6280impl flutter_rust_bridge::IntoIntoDart<crate::model::PayAmount> for crate::model::PayAmount {
6281 fn into_into_dart(self) -> crate::model::PayAmount {
6282 self
6283 }
6284}
6285impl flutter_rust_bridge::IntoDart for crate::model::PayOnchainRequest {
6287 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6288 [
6289 self.address.into_into_dart().into_dart(),
6290 self.prepare_response.into_into_dart().into_dart(),
6291 ]
6292 .into_dart()
6293 }
6294}
6295impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6296 for crate::model::PayOnchainRequest
6297{
6298}
6299impl flutter_rust_bridge::IntoIntoDart<crate::model::PayOnchainRequest>
6300 for crate::model::PayOnchainRequest
6301{
6302 fn into_into_dart(self) -> crate::model::PayOnchainRequest {
6303 self
6304 }
6305}
6306impl flutter_rust_bridge::IntoDart for crate::model::Payment {
6308 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6309 [
6310 self.destination.into_into_dart().into_dart(),
6311 self.tx_id.into_into_dart().into_dart(),
6312 self.unblinding_data.into_into_dart().into_dart(),
6313 self.timestamp.into_into_dart().into_dart(),
6314 self.amount_sat.into_into_dart().into_dart(),
6315 self.fees_sat.into_into_dart().into_dart(),
6316 self.swapper_fees_sat.into_into_dart().into_dart(),
6317 self.payment_type.into_into_dart().into_dart(),
6318 self.status.into_into_dart().into_dart(),
6319 self.details.into_into_dart().into_dart(),
6320 ]
6321 .into_dart()
6322 }
6323}
6324impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Payment {}
6325impl flutter_rust_bridge::IntoIntoDart<crate::model::Payment> for crate::model::Payment {
6326 fn into_into_dart(self) -> crate::model::Payment {
6327 self
6328 }
6329}
6330impl flutter_rust_bridge::IntoDart for crate::model::PaymentDetails {
6332 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6333 match self {
6334 crate::model::PaymentDetails::Lightning {
6335 swap_id,
6336 description,
6337 liquid_expiration_blockheight,
6338 preimage,
6339 invoice,
6340 bolt12_offer,
6341 payment_hash,
6342 destination_pubkey,
6343 lnurl_info,
6344 bip353_address,
6345 claim_tx_id,
6346 refund_tx_id,
6347 refund_tx_amount_sat,
6348 } => [
6349 0.into_dart(),
6350 swap_id.into_into_dart().into_dart(),
6351 description.into_into_dart().into_dart(),
6352 liquid_expiration_blockheight.into_into_dart().into_dart(),
6353 preimage.into_into_dart().into_dart(),
6354 invoice.into_into_dart().into_dart(),
6355 bolt12_offer.into_into_dart().into_dart(),
6356 payment_hash.into_into_dart().into_dart(),
6357 destination_pubkey.into_into_dart().into_dart(),
6358 lnurl_info.into_into_dart().into_dart(),
6359 bip353_address.into_into_dart().into_dart(),
6360 claim_tx_id.into_into_dart().into_dart(),
6361 refund_tx_id.into_into_dart().into_dart(),
6362 refund_tx_amount_sat.into_into_dart().into_dart(),
6363 ]
6364 .into_dart(),
6365 crate::model::PaymentDetails::Liquid {
6366 destination,
6367 description,
6368 asset_id,
6369 asset_info,
6370 lnurl_info,
6371 bip353_address,
6372 } => [
6373 1.into_dart(),
6374 destination.into_into_dart().into_dart(),
6375 description.into_into_dart().into_dart(),
6376 asset_id.into_into_dart().into_dart(),
6377 asset_info.into_into_dart().into_dart(),
6378 lnurl_info.into_into_dart().into_dart(),
6379 bip353_address.into_into_dart().into_dart(),
6380 ]
6381 .into_dart(),
6382 crate::model::PaymentDetails::Bitcoin {
6383 swap_id,
6384 description,
6385 auto_accepted_fees,
6386 liquid_expiration_blockheight,
6387 bitcoin_expiration_blockheight,
6388 claim_tx_id,
6389 refund_tx_id,
6390 refund_tx_amount_sat,
6391 } => [
6392 2.into_dart(),
6393 swap_id.into_into_dart().into_dart(),
6394 description.into_into_dart().into_dart(),
6395 auto_accepted_fees.into_into_dart().into_dart(),
6396 liquid_expiration_blockheight.into_into_dart().into_dart(),
6397 bitcoin_expiration_blockheight.into_into_dart().into_dart(),
6398 claim_tx_id.into_into_dart().into_dart(),
6399 refund_tx_id.into_into_dart().into_dart(),
6400 refund_tx_amount_sat.into_into_dart().into_dart(),
6401 ]
6402 .into_dart(),
6403 _ => {
6404 unimplemented!("");
6405 }
6406 }
6407 }
6408}
6409impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentDetails {}
6410impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentDetails>
6411 for crate::model::PaymentDetails
6412{
6413 fn into_into_dart(self) -> crate::model::PaymentDetails {
6414 self
6415 }
6416}
6417impl flutter_rust_bridge::IntoDart for crate::error::PaymentError {
6419 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6420 match self {
6421 crate::error::PaymentError::AlreadyClaimed => [0.into_dart()].into_dart(),
6422 crate::error::PaymentError::AlreadyPaid => [1.into_dart()].into_dart(),
6423 crate::error::PaymentError::PaymentInProgress => [2.into_dart()].into_dart(),
6424 crate::error::PaymentError::AmountOutOfRange => [3.into_dart()].into_dart(),
6425 crate::error::PaymentError::AmountMissing { err } => {
6426 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6427 }
6428 crate::error::PaymentError::AssetError { err } => {
6429 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6430 }
6431 crate::error::PaymentError::InvalidNetwork { err } => {
6432 [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
6433 }
6434 crate::error::PaymentError::Generic { err } => {
6435 [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
6436 }
6437 crate::error::PaymentError::InvalidOrExpiredFees => [8.into_dart()].into_dart(),
6438 crate::error::PaymentError::InsufficientFunds => [9.into_dart()].into_dart(),
6439 crate::error::PaymentError::InvalidDescription { err } => {
6440 [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6441 }
6442 crate::error::PaymentError::InvalidInvoice { err } => {
6443 [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6444 }
6445 crate::error::PaymentError::InvalidPreimage => [12.into_dart()].into_dart(),
6446 crate::error::PaymentError::PairsNotFound => [13.into_dart()].into_dart(),
6447 crate::error::PaymentError::PaymentTimeout => [14.into_dart()].into_dart(),
6448 crate::error::PaymentError::PersistError => [15.into_dart()].into_dart(),
6449 crate::error::PaymentError::ReceiveError { err } => {
6450 [16.into_dart(), err.into_into_dart().into_dart()].into_dart()
6451 }
6452 crate::error::PaymentError::Refunded { err, refund_tx_id } => [
6453 17.into_dart(),
6454 err.into_into_dart().into_dart(),
6455 refund_tx_id.into_into_dart().into_dart(),
6456 ]
6457 .into_dart(),
6458 crate::error::PaymentError::SelfTransferNotSupported => [18.into_dart()].into_dart(),
6459 crate::error::PaymentError::SendError { err } => {
6460 [19.into_dart(), err.into_into_dart().into_dart()].into_dart()
6461 }
6462 crate::error::PaymentError::SignerError { err } => {
6463 [20.into_dart(), err.into_into_dart().into_dart()].into_dart()
6464 }
6465 _ => {
6466 unimplemented!("");
6467 }
6468 }
6469 }
6470}
6471impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::PaymentError {}
6472impl flutter_rust_bridge::IntoIntoDart<crate::error::PaymentError> for crate::error::PaymentError {
6473 fn into_into_dart(self) -> crate::error::PaymentError {
6474 self
6475 }
6476}
6477impl flutter_rust_bridge::IntoDart for crate::model::PaymentMethod {
6479 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6480 match self {
6481 Self::Lightning => 0.into_dart(),
6482 Self::BitcoinAddress => 1.into_dart(),
6483 Self::LiquidAddress => 2.into_dart(),
6484 _ => unreachable!(),
6485 }
6486 }
6487}
6488impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentMethod {}
6489impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentMethod>
6490 for crate::model::PaymentMethod
6491{
6492 fn into_into_dart(self) -> crate::model::PaymentMethod {
6493 self
6494 }
6495}
6496impl flutter_rust_bridge::IntoDart for crate::model::PaymentState {
6498 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6499 match self {
6500 Self::Created => 0.into_dart(),
6501 Self::Pending => 1.into_dart(),
6502 Self::Complete => 2.into_dart(),
6503 Self::Failed => 3.into_dart(),
6504 Self::TimedOut => 4.into_dart(),
6505 Self::Refundable => 5.into_dart(),
6506 Self::RefundPending => 6.into_dart(),
6507 Self::WaitingFeeAcceptance => 7.into_dart(),
6508 _ => unreachable!(),
6509 }
6510 }
6511}
6512impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentState {}
6513impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentState> for crate::model::PaymentState {
6514 fn into_into_dart(self) -> crate::model::PaymentState {
6515 self
6516 }
6517}
6518impl flutter_rust_bridge::IntoDart for crate::model::PaymentType {
6520 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6521 match self {
6522 Self::Receive => 0.into_dart(),
6523 Self::Send => 1.into_dart(),
6524 _ => unreachable!(),
6525 }
6526 }
6527}
6528impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentType {}
6529impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentType> for crate::model::PaymentType {
6530 fn into_into_dart(self) -> crate::model::PaymentType {
6531 self
6532 }
6533}
6534impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinRequest {
6536 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6537 [
6538 self.provider.into_into_dart().into_dart(),
6539 self.amount_sat.into_into_dart().into_dart(),
6540 ]
6541 .into_dart()
6542 }
6543}
6544impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6545 for crate::model::PrepareBuyBitcoinRequest
6546{
6547}
6548impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinRequest>
6549 for crate::model::PrepareBuyBitcoinRequest
6550{
6551 fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinRequest {
6552 self
6553 }
6554}
6555impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinResponse {
6557 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6558 [
6559 self.provider.into_into_dart().into_dart(),
6560 self.amount_sat.into_into_dart().into_dart(),
6561 self.fees_sat.into_into_dart().into_dart(),
6562 ]
6563 .into_dart()
6564 }
6565}
6566impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6567 for crate::model::PrepareBuyBitcoinResponse
6568{
6569}
6570impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinResponse>
6571 for crate::model::PrepareBuyBitcoinResponse
6572{
6573 fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinResponse {
6574 self
6575 }
6576}
6577impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayRequest {
6579 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6580 [
6581 self.data.into_into_dart().into_dart(),
6582 self.amount.into_into_dart().into_dart(),
6583 self.bip353_address.into_into_dart().into_dart(),
6584 self.comment.into_into_dart().into_dart(),
6585 self.validate_success_action_url
6586 .into_into_dart()
6587 .into_dart(),
6588 ]
6589 .into_dart()
6590 }
6591}
6592impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6593 for crate::model::PrepareLnUrlPayRequest
6594{
6595}
6596impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayRequest>
6597 for crate::model::PrepareLnUrlPayRequest
6598{
6599 fn into_into_dart(self) -> crate::model::PrepareLnUrlPayRequest {
6600 self
6601 }
6602}
6603impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayResponse {
6605 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6606 [
6607 self.destination.into_into_dart().into_dart(),
6608 self.fees_sat.into_into_dart().into_dart(),
6609 self.data.into_into_dart().into_dart(),
6610 self.comment.into_into_dart().into_dart(),
6611 self.success_action.into_into_dart().into_dart(),
6612 ]
6613 .into_dart()
6614 }
6615}
6616impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6617 for crate::model::PrepareLnUrlPayResponse
6618{
6619}
6620impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayResponse>
6621 for crate::model::PrepareLnUrlPayResponse
6622{
6623 fn into_into_dart(self) -> crate::model::PrepareLnUrlPayResponse {
6624 self
6625 }
6626}
6627impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainRequest {
6629 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6630 [
6631 self.amount.into_into_dart().into_dart(),
6632 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6633 ]
6634 .into_dart()
6635 }
6636}
6637impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6638 for crate::model::PreparePayOnchainRequest
6639{
6640}
6641impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainRequest>
6642 for crate::model::PreparePayOnchainRequest
6643{
6644 fn into_into_dart(self) -> crate::model::PreparePayOnchainRequest {
6645 self
6646 }
6647}
6648impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainResponse {
6650 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6651 [
6652 self.receiver_amount_sat.into_into_dart().into_dart(),
6653 self.claim_fees_sat.into_into_dart().into_dart(),
6654 self.total_fees_sat.into_into_dart().into_dart(),
6655 ]
6656 .into_dart()
6657 }
6658}
6659impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6660 for crate::model::PreparePayOnchainResponse
6661{
6662}
6663impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainResponse>
6664 for crate::model::PreparePayOnchainResponse
6665{
6666 fn into_into_dart(self) -> crate::model::PreparePayOnchainResponse {
6667 self
6668 }
6669}
6670impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveRequest {
6672 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6673 [
6674 self.payment_method.into_into_dart().into_dart(),
6675 self.amount.into_into_dart().into_dart(),
6676 ]
6677 .into_dart()
6678 }
6679}
6680impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6681 for crate::model::PrepareReceiveRequest
6682{
6683}
6684impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveRequest>
6685 for crate::model::PrepareReceiveRequest
6686{
6687 fn into_into_dart(self) -> crate::model::PrepareReceiveRequest {
6688 self
6689 }
6690}
6691impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveResponse {
6693 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6694 [
6695 self.payment_method.into_into_dart().into_dart(),
6696 self.amount.into_into_dart().into_dart(),
6697 self.fees_sat.into_into_dart().into_dart(),
6698 self.min_payer_amount_sat.into_into_dart().into_dart(),
6699 self.max_payer_amount_sat.into_into_dart().into_dart(),
6700 self.swapper_feerate.into_into_dart().into_dart(),
6701 ]
6702 .into_dart()
6703 }
6704}
6705impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6706 for crate::model::PrepareReceiveResponse
6707{
6708}
6709impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveResponse>
6710 for crate::model::PrepareReceiveResponse
6711{
6712 fn into_into_dart(self) -> crate::model::PrepareReceiveResponse {
6713 self
6714 }
6715}
6716impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundRequest {
6718 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6719 [
6720 self.swap_address.into_into_dart().into_dart(),
6721 self.refund_address.into_into_dart().into_dart(),
6722 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6723 ]
6724 .into_dart()
6725 }
6726}
6727impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6728 for crate::model::PrepareRefundRequest
6729{
6730}
6731impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundRequest>
6732 for crate::model::PrepareRefundRequest
6733{
6734 fn into_into_dart(self) -> crate::model::PrepareRefundRequest {
6735 self
6736 }
6737}
6738impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundResponse {
6740 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6741 [
6742 self.tx_vsize.into_into_dart().into_dart(),
6743 self.tx_fee_sat.into_into_dart().into_dart(),
6744 self.last_refund_tx_id.into_into_dart().into_dart(),
6745 ]
6746 .into_dart()
6747 }
6748}
6749impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6750 for crate::model::PrepareRefundResponse
6751{
6752}
6753impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundResponse>
6754 for crate::model::PrepareRefundResponse
6755{
6756 fn into_into_dart(self) -> crate::model::PrepareRefundResponse {
6757 self
6758 }
6759}
6760impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendRequest {
6762 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6763 [
6764 self.destination.into_into_dart().into_dart(),
6765 self.amount.into_into_dart().into_dart(),
6766 ]
6767 .into_dart()
6768 }
6769}
6770impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6771 for crate::model::PrepareSendRequest
6772{
6773}
6774impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendRequest>
6775 for crate::model::PrepareSendRequest
6776{
6777 fn into_into_dart(self) -> crate::model::PrepareSendRequest {
6778 self
6779 }
6780}
6781impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendResponse {
6783 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6784 [
6785 self.destination.into_into_dart().into_dart(),
6786 self.fees_sat.into_into_dart().into_dart(),
6787 self.estimated_asset_fees.into_into_dart().into_dart(),
6788 ]
6789 .into_dart()
6790 }
6791}
6792impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6793 for crate::model::PrepareSendResponse
6794{
6795}
6796impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendResponse>
6797 for crate::model::PrepareSendResponse
6798{
6799 fn into_into_dart(self) -> crate::model::PrepareSendResponse {
6800 self
6801 }
6802}
6803impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Rate> {
6805 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6806 [
6807 self.0.coin.into_into_dart().into_dart(),
6808 self.0.value.into_into_dart().into_dart(),
6809 ]
6810 .into_dart()
6811 }
6812}
6813impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6814 for FrbWrapper<crate::bindings::Rate>
6815{
6816}
6817impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Rate>>
6818 for crate::bindings::Rate
6819{
6820 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Rate> {
6821 self.into()
6822 }
6823}
6824impl flutter_rust_bridge::IntoDart for crate::model::ReceiveAmount {
6826 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6827 match self {
6828 crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
6829 [0.into_dart(), payer_amount_sat.into_into_dart().into_dart()].into_dart()
6830 }
6831 crate::model::ReceiveAmount::Asset {
6832 asset_id,
6833 payer_amount,
6834 } => [
6835 1.into_dart(),
6836 asset_id.into_into_dart().into_dart(),
6837 payer_amount.into_into_dart().into_dart(),
6838 ]
6839 .into_dart(),
6840 _ => {
6841 unimplemented!("");
6842 }
6843 }
6844 }
6845}
6846impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ReceiveAmount {}
6847impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceiveAmount>
6848 for crate::model::ReceiveAmount
6849{
6850 fn into_into_dart(self) -> crate::model::ReceiveAmount {
6851 self
6852 }
6853}
6854impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentRequest {
6856 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6857 [
6858 self.prepare_response.into_into_dart().into_dart(),
6859 self.description.into_into_dart().into_dart(),
6860 self.use_description_hash.into_into_dart().into_dart(),
6861 ]
6862 .into_dart()
6863 }
6864}
6865impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6866 for crate::model::ReceivePaymentRequest
6867{
6868}
6869impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentRequest>
6870 for crate::model::ReceivePaymentRequest
6871{
6872 fn into_into_dart(self) -> crate::model::ReceivePaymentRequest {
6873 self
6874 }
6875}
6876impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentResponse {
6878 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6879 [self.destination.into_into_dart().into_dart()].into_dart()
6880 }
6881}
6882impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6883 for crate::model::ReceivePaymentResponse
6884{
6885}
6886impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentResponse>
6887 for crate::model::ReceivePaymentResponse
6888{
6889 fn into_into_dart(self) -> crate::model::ReceivePaymentResponse {
6890 self
6891 }
6892}
6893impl flutter_rust_bridge::IntoDart for crate::model::RecommendedFees {
6895 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6896 [
6897 self.fastest_fee.into_into_dart().into_dart(),
6898 self.half_hour_fee.into_into_dart().into_dart(),
6899 self.hour_fee.into_into_dart().into_dart(),
6900 self.economy_fee.into_into_dart().into_dart(),
6901 self.minimum_fee.into_into_dart().into_dart(),
6902 ]
6903 .into_dart()
6904 }
6905}
6906impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RecommendedFees {}
6907impl flutter_rust_bridge::IntoIntoDart<crate::model::RecommendedFees>
6908 for crate::model::RecommendedFees
6909{
6910 fn into_into_dart(self) -> crate::model::RecommendedFees {
6911 self
6912 }
6913}
6914impl flutter_rust_bridge::IntoDart for crate::model::RefundRequest {
6916 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6917 [
6918 self.swap_address.into_into_dart().into_dart(),
6919 self.refund_address.into_into_dart().into_dart(),
6920 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6921 ]
6922 .into_dart()
6923 }
6924}
6925impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundRequest {}
6926impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundRequest>
6927 for crate::model::RefundRequest
6928{
6929 fn into_into_dart(self) -> crate::model::RefundRequest {
6930 self
6931 }
6932}
6933impl flutter_rust_bridge::IntoDart for crate::model::RefundResponse {
6935 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6936 [self.refund_tx_id.into_into_dart().into_dart()].into_dart()
6937 }
6938}
6939impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundResponse {}
6940impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundResponse>
6941 for crate::model::RefundResponse
6942{
6943 fn into_into_dart(self) -> crate::model::RefundResponse {
6944 self
6945 }
6946}
6947impl flutter_rust_bridge::IntoDart for crate::model::RefundableSwap {
6949 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6950 [
6951 self.swap_address.into_into_dart().into_dart(),
6952 self.timestamp.into_into_dart().into_dart(),
6953 self.amount_sat.into_into_dart().into_dart(),
6954 self.last_refund_tx_id.into_into_dart().into_dart(),
6955 ]
6956 .into_dart()
6957 }
6958}
6959impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundableSwap {}
6960impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundableSwap>
6961 for crate::model::RefundableSwap
6962{
6963 fn into_into_dart(self) -> crate::model::RefundableSwap {
6964 self
6965 }
6966}
6967impl flutter_rust_bridge::IntoDart for crate::model::RestoreRequest {
6969 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6970 [self.backup_path.into_into_dart().into_dart()].into_dart()
6971 }
6972}
6973impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RestoreRequest {}
6974impl flutter_rust_bridge::IntoIntoDart<crate::model::RestoreRequest>
6975 for crate::model::RestoreRequest
6976{
6977 fn into_into_dart(self) -> crate::model::RestoreRequest {
6978 self
6979 }
6980}
6981impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHint> {
6983 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6984 [self.0.hops.into_into_dart().into_dart()].into_dart()
6985 }
6986}
6987impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6988 for FrbWrapper<crate::bindings::RouteHint>
6989{
6990}
6991impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHint>>
6992 for crate::bindings::RouteHint
6993{
6994 fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHint> {
6995 self.into()
6996 }
6997}
6998impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHintHop> {
7000 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7001 [
7002 self.0.src_node_id.into_into_dart().into_dart(),
7003 self.0.short_channel_id.into_into_dart().into_dart(),
7004 self.0.fees_base_msat.into_into_dart().into_dart(),
7005 self.0
7006 .fees_proportional_millionths
7007 .into_into_dart()
7008 .into_dart(),
7009 self.0.cltv_expiry_delta.into_into_dart().into_dart(),
7010 self.0.htlc_minimum_msat.into_into_dart().into_dart(),
7011 self.0.htlc_maximum_msat.into_into_dart().into_dart(),
7012 ]
7013 .into_dart()
7014 }
7015}
7016impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7017 for FrbWrapper<crate::bindings::RouteHintHop>
7018{
7019}
7020impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHintHop>>
7021 for crate::bindings::RouteHintHop
7022{
7023 fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHintHop> {
7024 self.into()
7025 }
7026}
7027impl flutter_rust_bridge::IntoDart for crate::error::SdkError {
7029 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7030 match self {
7031 crate::error::SdkError::AlreadyStarted => [0.into_dart()].into_dart(),
7032 crate::error::SdkError::Generic { err } => {
7033 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
7034 }
7035 crate::error::SdkError::NotStarted => [2.into_dart()].into_dart(),
7036 crate::error::SdkError::ServiceConnectivity { err } => {
7037 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
7038 }
7039 _ => {
7040 unimplemented!("");
7041 }
7042 }
7043 }
7044}
7045impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::SdkError {}
7046impl flutter_rust_bridge::IntoIntoDart<crate::error::SdkError> for crate::error::SdkError {
7047 fn into_into_dart(self) -> crate::error::SdkError {
7048 self
7049 }
7050}
7051impl flutter_rust_bridge::IntoDart for crate::model::SdkEvent {
7053 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7054 match self {
7055 crate::model::SdkEvent::PaymentFailed { details } => {
7056 [0.into_dart(), details.into_into_dart().into_dart()].into_dart()
7057 }
7058 crate::model::SdkEvent::PaymentPending { details } => {
7059 [1.into_dart(), details.into_into_dart().into_dart()].into_dart()
7060 }
7061 crate::model::SdkEvent::PaymentRefundable { details } => {
7062 [2.into_dart(), details.into_into_dart().into_dart()].into_dart()
7063 }
7064 crate::model::SdkEvent::PaymentRefunded { details } => {
7065 [3.into_dart(), details.into_into_dart().into_dart()].into_dart()
7066 }
7067 crate::model::SdkEvent::PaymentRefundPending { details } => {
7068 [4.into_dart(), details.into_into_dart().into_dart()].into_dart()
7069 }
7070 crate::model::SdkEvent::PaymentSucceeded { details } => {
7071 [5.into_dart(), details.into_into_dart().into_dart()].into_dart()
7072 }
7073 crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
7074 [6.into_dart(), details.into_into_dart().into_dart()].into_dart()
7075 }
7076 crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
7077 [7.into_dart(), details.into_into_dart().into_dart()].into_dart()
7078 }
7079 crate::model::SdkEvent::Synced => [8.into_dart()].into_dart(),
7080 crate::model::SdkEvent::DataSynced {
7081 did_pull_new_records,
7082 } => [
7083 9.into_dart(),
7084 did_pull_new_records.into_into_dart().into_dart(),
7085 ]
7086 .into_dart(),
7087 _ => {
7088 unimplemented!("");
7089 }
7090 }
7091 }
7092}
7093impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SdkEvent {}
7094impl flutter_rust_bridge::IntoIntoDart<crate::model::SdkEvent> for crate::model::SdkEvent {
7095 fn into_into_dart(self) -> crate::model::SdkEvent {
7096 self
7097 }
7098}
7099impl flutter_rust_bridge::IntoDart for crate::model::SendDestination {
7101 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7102 match self {
7103 crate::model::SendDestination::LiquidAddress {
7104 address_data,
7105 bip353_address,
7106 } => [
7107 0.into_dart(),
7108 address_data.into_into_dart().into_dart(),
7109 bip353_address.into_into_dart().into_dart(),
7110 ]
7111 .into_dart(),
7112 crate::model::SendDestination::Bolt11 {
7113 invoice,
7114 bip353_address,
7115 } => [
7116 1.into_dart(),
7117 invoice.into_into_dart().into_dart(),
7118 bip353_address.into_into_dart().into_dart(),
7119 ]
7120 .into_dart(),
7121 crate::model::SendDestination::Bolt12 {
7122 offer,
7123 receiver_amount_sat,
7124 bip353_address,
7125 } => [
7126 2.into_dart(),
7127 offer.into_into_dart().into_dart(),
7128 receiver_amount_sat.into_into_dart().into_dart(),
7129 bip353_address.into_into_dart().into_dart(),
7130 ]
7131 .into_dart(),
7132 _ => {
7133 unimplemented!("");
7134 }
7135 }
7136 }
7137}
7138impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SendDestination {}
7139impl flutter_rust_bridge::IntoIntoDart<crate::model::SendDestination>
7140 for crate::model::SendDestination
7141{
7142 fn into_into_dart(self) -> crate::model::SendDestination {
7143 self
7144 }
7145}
7146impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentRequest {
7148 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7149 [
7150 self.prepare_response.into_into_dart().into_dart(),
7151 self.use_asset_fees.into_into_dart().into_dart(),
7152 ]
7153 .into_dart()
7154 }
7155}
7156impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7157 for crate::model::SendPaymentRequest
7158{
7159}
7160impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentRequest>
7161 for crate::model::SendPaymentRequest
7162{
7163 fn into_into_dart(self) -> crate::model::SendPaymentRequest {
7164 self
7165 }
7166}
7167impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentResponse {
7169 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7170 [self.payment.into_into_dart().into_dart()].into_dart()
7171 }
7172}
7173impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7174 for crate::model::SendPaymentResponse
7175{
7176}
7177impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentResponse>
7178 for crate::model::SendPaymentResponse
7179{
7180 fn into_into_dart(self) -> crate::model::SendPaymentResponse {
7181 self
7182 }
7183}
7184impl flutter_rust_bridge::IntoDart for crate::model::SignMessageRequest {
7186 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7187 [self.message.into_into_dart().into_dart()].into_dart()
7188 }
7189}
7190impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7191 for crate::model::SignMessageRequest
7192{
7193}
7194impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageRequest>
7195 for crate::model::SignMessageRequest
7196{
7197 fn into_into_dart(self) -> crate::model::SignMessageRequest {
7198 self
7199 }
7200}
7201impl flutter_rust_bridge::IntoDart for crate::model::SignMessageResponse {
7203 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7204 [self.signature.into_into_dart().into_dart()].into_dart()
7205 }
7206}
7207impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7208 for crate::model::SignMessageResponse
7209{
7210}
7211impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageResponse>
7212 for crate::model::SignMessageResponse
7213{
7214 fn into_into_dart(self) -> crate::model::SignMessageResponse {
7215 self
7216 }
7217}
7218impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessAction> {
7220 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7221 match self.0 {
7222 crate::bindings::SuccessAction::Aes { data } => {
7223 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
7224 }
7225 crate::bindings::SuccessAction::Message { data } => {
7226 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7227 }
7228 crate::bindings::SuccessAction::Url { data } => {
7229 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7230 }
7231 _ => {
7232 unimplemented!("");
7233 }
7234 }
7235 }
7236}
7237impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7238 for FrbWrapper<crate::bindings::SuccessAction>
7239{
7240}
7241impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessAction>>
7242 for crate::bindings::SuccessAction
7243{
7244 fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessAction> {
7245 self.into()
7246 }
7247}
7248impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessActionProcessed> {
7250 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7251 match self.0 {
7252 crate::bindings::SuccessActionProcessed::Aes { result } => {
7253 [0.into_dart(), result.into_into_dart().into_dart()].into_dart()
7254 }
7255 crate::bindings::SuccessActionProcessed::Message { data } => {
7256 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7257 }
7258 crate::bindings::SuccessActionProcessed::Url { data } => {
7259 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7260 }
7261 _ => {
7262 unimplemented!("");
7263 }
7264 }
7265 }
7266}
7267impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7268 for FrbWrapper<crate::bindings::SuccessActionProcessed>
7269{
7270}
7271impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessActionProcessed>>
7272 for crate::bindings::SuccessActionProcessed
7273{
7274 fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessActionProcessed> {
7275 self.into()
7276 }
7277}
7278impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Symbol> {
7280 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7281 [
7282 self.0.grapheme.into_into_dart().into_dart(),
7283 self.0.template.into_into_dart().into_dart(),
7284 self.0.rtl.into_into_dart().into_dart(),
7285 self.0.position.into_into_dart().into_dart(),
7286 ]
7287 .into_dart()
7288 }
7289}
7290impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7291 for FrbWrapper<crate::bindings::Symbol>
7292{
7293}
7294impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Symbol>>
7295 for crate::bindings::Symbol
7296{
7297 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Symbol> {
7298 self.into()
7299 }
7300}
7301impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::UrlSuccessActionData> {
7303 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7304 [
7305 self.0.description.into_into_dart().into_dart(),
7306 self.0.url.into_into_dart().into_dart(),
7307 self.0.matches_callback_domain.into_into_dart().into_dart(),
7308 ]
7309 .into_dart()
7310 }
7311}
7312impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7313 for FrbWrapper<crate::bindings::UrlSuccessActionData>
7314{
7315}
7316impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::UrlSuccessActionData>>
7317 for crate::bindings::UrlSuccessActionData
7318{
7319 fn into_into_dart(self) -> FrbWrapper<crate::bindings::UrlSuccessActionData> {
7320 self.into()
7321 }
7322}
7323impl flutter_rust_bridge::IntoDart for crate::model::WalletInfo {
7325 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7326 [
7327 self.balance_sat.into_into_dart().into_dart(),
7328 self.pending_send_sat.into_into_dart().into_dart(),
7329 self.pending_receive_sat.into_into_dart().into_dart(),
7330 self.fingerprint.into_into_dart().into_dart(),
7331 self.pubkey.into_into_dart().into_dart(),
7332 self.asset_balances.into_into_dart().into_dart(),
7333 ]
7334 .into_dart()
7335 }
7336}
7337impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::WalletInfo {}
7338impl flutter_rust_bridge::IntoIntoDart<crate::model::WalletInfo> for crate::model::WalletInfo {
7339 fn into_into_dart(self) -> crate::model::WalletInfo {
7340 self
7341 }
7342}
7343
7344impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
7345 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7347 <String>::sse_encode(format!("{:?}", self), serializer);
7348 }
7349}
7350
7351impl SseEncode for BindingLiquidSdk {
7352 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7354 <RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer);
7355 }
7356}
7357
7358impl SseEncode
7359 for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
7360{
7361 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7363 let (ptr, size) = self.sse_encode_raw();
7364 <usize>::sse_encode(ptr, serializer);
7365 <i32>::sse_encode(size, serializer);
7366 }
7367}
7368
7369impl SseEncode
7370 for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
7371{
7372 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7374 unimplemented!("")
7375 }
7376}
7377
7378impl SseEncode
7379 for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
7380{
7381 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7383 unimplemented!("")
7384 }
7385}
7386
7387impl SseEncode for String {
7388 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7390 <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
7391 }
7392}
7393
7394impl SseEncode for crate::model::AcceptPaymentProposedFeesRequest {
7395 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7397 <crate::model::FetchPaymentProposedFeesResponse>::sse_encode(self.response, serializer);
7398 }
7399}
7400
7401impl SseEncode for crate::bindings::AesSuccessActionData {
7402 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7404 <String>::sse_encode(self.description, serializer);
7405 <String>::sse_encode(self.ciphertext, serializer);
7406 <String>::sse_encode(self.iv, serializer);
7407 }
7408}
7409
7410impl SseEncode for crate::bindings::AesSuccessActionDataDecrypted {
7411 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7413 <String>::sse_encode(self.description, serializer);
7414 <String>::sse_encode(self.plaintext, serializer);
7415 }
7416}
7417
7418impl SseEncode for crate::bindings::AesSuccessActionDataResult {
7419 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7421 match self {
7422 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
7423 <i32>::sse_encode(0, serializer);
7424 <crate::bindings::AesSuccessActionDataDecrypted>::sse_encode(data, serializer);
7425 }
7426 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
7427 <i32>::sse_encode(1, serializer);
7428 <String>::sse_encode(reason, serializer);
7429 }
7430 _ => {
7431 unimplemented!("");
7432 }
7433 }
7434 }
7435}
7436
7437impl SseEncode for crate::bindings::Amount {
7438 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7440 match self {
7441 crate::bindings::Amount::Bitcoin { amount_msat } => {
7442 <i32>::sse_encode(0, serializer);
7443 <u64>::sse_encode(amount_msat, serializer);
7444 }
7445 crate::bindings::Amount::Currency {
7446 iso4217_code,
7447 fractional_amount,
7448 } => {
7449 <i32>::sse_encode(1, serializer);
7450 <String>::sse_encode(iso4217_code, serializer);
7451 <u64>::sse_encode(fractional_amount, serializer);
7452 }
7453 _ => {
7454 unimplemented!("");
7455 }
7456 }
7457 }
7458}
7459
7460impl SseEncode for crate::model::AssetBalance {
7461 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7463 <String>::sse_encode(self.asset_id, serializer);
7464 <u64>::sse_encode(self.balance_sat, serializer);
7465 <Option<String>>::sse_encode(self.name, serializer);
7466 <Option<String>>::sse_encode(self.ticker, serializer);
7467 <Option<f64>>::sse_encode(self.balance, serializer);
7468 }
7469}
7470
7471impl SseEncode for crate::model::AssetInfo {
7472 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7474 <String>::sse_encode(self.name, serializer);
7475 <String>::sse_encode(self.ticker, serializer);
7476 <f64>::sse_encode(self.amount, serializer);
7477 <Option<f64>>::sse_encode(self.fees, serializer);
7478 }
7479}
7480
7481impl SseEncode for crate::model::AssetMetadata {
7482 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7484 <String>::sse_encode(self.asset_id, serializer);
7485 <String>::sse_encode(self.name, serializer);
7486 <String>::sse_encode(self.ticker, serializer);
7487 <u8>::sse_encode(self.precision, serializer);
7488 <Option<String>>::sse_encode(self.fiat_id, serializer);
7489 }
7490}
7491
7492impl SseEncode for crate::model::BackupRequest {
7493 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7495 <Option<String>>::sse_encode(self.backup_path, serializer);
7496 }
7497}
7498
7499impl SseEncode for crate::bindings::BindingEventListener {
7500 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7502 <StreamSink<crate::model::SdkEvent,flutter_rust_bridge::for_generated::DcoCodec>>::sse_encode(self.stream, serializer);
7503 }
7504}
7505
7506impl SseEncode for crate::bindings::BitcoinAddressData {
7507 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7509 <String>::sse_encode(self.address, serializer);
7510 <crate::bindings::Network>::sse_encode(self.network, serializer);
7511 <Option<u64>>::sse_encode(self.amount_sat, serializer);
7512 <Option<String>>::sse_encode(self.label, serializer);
7513 <Option<String>>::sse_encode(self.message, serializer);
7514 }
7515}
7516
7517impl SseEncode for crate::model::BlockchainExplorer {
7518 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7520 match self {
7521 crate::model::BlockchainExplorer::Electrum { url } => {
7522 <i32>::sse_encode(0, serializer);
7523 <String>::sse_encode(url, serializer);
7524 }
7525 crate::model::BlockchainExplorer::Esplora {
7526 url,
7527 use_waterfalls,
7528 } => {
7529 <i32>::sse_encode(1, serializer);
7530 <String>::sse_encode(url, serializer);
7531 <bool>::sse_encode(use_waterfalls, serializer);
7532 }
7533 _ => {
7534 unimplemented!("");
7535 }
7536 }
7537 }
7538}
7539
7540impl SseEncode for crate::model::BlockchainInfo {
7541 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7543 <u32>::sse_encode(self.liquid_tip, serializer);
7544 <u32>::sse_encode(self.bitcoin_tip, serializer);
7545 }
7546}
7547
7548impl SseEncode for bool {
7549 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7551 serializer.cursor.write_u8(self as _).unwrap();
7552 }
7553}
7554
7555impl SseEncode for crate::model::BuyBitcoinProvider {
7556 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7558 <i32>::sse_encode(
7559 match self {
7560 crate::model::BuyBitcoinProvider::Moonpay => 0,
7561 _ => {
7562 unimplemented!("");
7563 }
7564 },
7565 serializer,
7566 );
7567 }
7568}
7569
7570impl SseEncode for crate::model::BuyBitcoinRequest {
7571 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7573 <crate::model::PrepareBuyBitcoinResponse>::sse_encode(self.prepare_response, serializer);
7574 <Option<String>>::sse_encode(self.redirect_url, serializer);
7575 }
7576}
7577
7578impl SseEncode for crate::model::CheckMessageRequest {
7579 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7581 <String>::sse_encode(self.message, serializer);
7582 <String>::sse_encode(self.pubkey, serializer);
7583 <String>::sse_encode(self.signature, serializer);
7584 }
7585}
7586
7587impl SseEncode for crate::model::CheckMessageResponse {
7588 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7590 <bool>::sse_encode(self.is_valid, serializer);
7591 }
7592}
7593
7594impl SseEncode for crate::model::Config {
7595 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7597 <crate::model::BlockchainExplorer>::sse_encode(self.liquid_explorer, serializer);
7598 <crate::model::BlockchainExplorer>::sse_encode(self.bitcoin_explorer, serializer);
7599 <String>::sse_encode(self.working_dir, serializer);
7600 <Option<String>>::sse_encode(self.cache_dir, serializer);
7601 <crate::model::LiquidNetwork>::sse_encode(self.network, serializer);
7602 <u64>::sse_encode(self.payment_timeout_sec, serializer);
7603 <Option<String>>::sse_encode(self.sync_service_url, serializer);
7604 <Option<u64>>::sse_encode(self.zero_conf_max_amount_sat, serializer);
7605 <Option<String>>::sse_encode(self.breez_api_key, serializer);
7606 <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_encode(
7607 self.external_input_parsers,
7608 serializer,
7609 );
7610 <bool>::sse_encode(self.use_default_external_input_parsers, serializer);
7611 <Option<u32>>::sse_encode(self.onchain_fee_rate_leeway_sat_per_vbyte, serializer);
7612 <Option<Vec<crate::model::AssetMetadata>>>::sse_encode(self.asset_metadata, serializer);
7613 <Option<String>>::sse_encode(self.sideswap_api_key, serializer);
7614 }
7615}
7616
7617impl SseEncode for crate::model::ConnectRequest {
7618 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7620 <crate::model::Config>::sse_encode(self.config, serializer);
7621 <Option<String>>::sse_encode(self.mnemonic, serializer);
7622 <Option<String>>::sse_encode(self.passphrase, serializer);
7623 <Option<Vec<u8>>>::sse_encode(self.seed, serializer);
7624 }
7625}
7626
7627impl SseEncode for crate::bindings::CurrencyInfo {
7628 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7630 <String>::sse_encode(self.name, serializer);
7631 <u32>::sse_encode(self.fraction_size, serializer);
7632 <Option<u32>>::sse_encode(self.spacing, serializer);
7633 <Option<crate::bindings::Symbol>>::sse_encode(self.symbol, serializer);
7634 <Option<crate::bindings::Symbol>>::sse_encode(self.uniq_symbol, serializer);
7635 <Vec<crate::bindings::LocalizedName>>::sse_encode(self.localized_name, serializer);
7636 <Vec<crate::bindings::LocaleOverrides>>::sse_encode(self.locale_overrides, serializer);
7637 }
7638}
7639
7640impl SseEncode for crate::bindings::ExternalInputParser {
7641 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7643 <String>::sse_encode(self.provider_id, serializer);
7644 <String>::sse_encode(self.input_regex, serializer);
7645 <String>::sse_encode(self.parser_url, serializer);
7646 }
7647}
7648
7649impl SseEncode for f64 {
7650 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7652 serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
7653 }
7654}
7655
7656impl SseEncode for crate::model::FetchPaymentProposedFeesRequest {
7657 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7659 <String>::sse_encode(self.swap_id, serializer);
7660 }
7661}
7662
7663impl SseEncode for crate::model::FetchPaymentProposedFeesResponse {
7664 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7666 <String>::sse_encode(self.swap_id, serializer);
7667 <u64>::sse_encode(self.fees_sat, serializer);
7668 <u64>::sse_encode(self.payer_amount_sat, serializer);
7669 <u64>::sse_encode(self.receiver_amount_sat, serializer);
7670 }
7671}
7672
7673impl SseEncode for crate::bindings::FiatCurrency {
7674 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7676 <String>::sse_encode(self.id, serializer);
7677 <crate::bindings::CurrencyInfo>::sse_encode(self.info, serializer);
7678 }
7679}
7680
7681impl SseEncode for crate::model::GetInfoResponse {
7682 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7684 <crate::model::WalletInfo>::sse_encode(self.wallet_info, serializer);
7685 <crate::model::BlockchainInfo>::sse_encode(self.blockchain_info, serializer);
7686 }
7687}
7688
7689impl SseEncode for crate::model::GetPaymentRequest {
7690 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7692 match self {
7693 crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
7694 <i32>::sse_encode(0, serializer);
7695 <String>::sse_encode(payment_hash, serializer);
7696 }
7697 crate::model::GetPaymentRequest::SwapId { swap_id } => {
7698 <i32>::sse_encode(1, serializer);
7699 <String>::sse_encode(swap_id, serializer);
7700 }
7701 _ => {
7702 unimplemented!("");
7703 }
7704 }
7705 }
7706}
7707
7708impl SseEncode for i32 {
7709 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7711 serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
7712 }
7713}
7714
7715impl SseEncode for i64 {
7716 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7718 serializer.cursor.write_i64::<NativeEndian>(self).unwrap();
7719 }
7720}
7721
7722impl SseEncode for crate::bindings::InputType {
7723 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7725 match self {
7726 crate::bindings::InputType::BitcoinAddress { address } => {
7727 <i32>::sse_encode(0, serializer);
7728 <crate::bindings::BitcoinAddressData>::sse_encode(address, serializer);
7729 }
7730 crate::bindings::InputType::LiquidAddress { address } => {
7731 <i32>::sse_encode(1, serializer);
7732 <crate::bindings::LiquidAddressData>::sse_encode(address, serializer);
7733 }
7734 crate::bindings::InputType::Bolt11 { invoice } => {
7735 <i32>::sse_encode(2, serializer);
7736 <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
7737 }
7738 crate::bindings::InputType::Bolt12Offer {
7739 offer,
7740 bip353_address,
7741 } => {
7742 <i32>::sse_encode(3, serializer);
7743 <crate::bindings::LNOffer>::sse_encode(offer, serializer);
7744 <Option<String>>::sse_encode(bip353_address, serializer);
7745 }
7746 crate::bindings::InputType::NodeId { node_id } => {
7747 <i32>::sse_encode(4, serializer);
7748 <String>::sse_encode(node_id, serializer);
7749 }
7750 crate::bindings::InputType::Url { url } => {
7751 <i32>::sse_encode(5, serializer);
7752 <String>::sse_encode(url, serializer);
7753 }
7754 crate::bindings::InputType::LnUrlPay {
7755 data,
7756 bip353_address,
7757 } => {
7758 <i32>::sse_encode(6, serializer);
7759 <crate::bindings::LnUrlPayRequestData>::sse_encode(data, serializer);
7760 <Option<String>>::sse_encode(bip353_address, serializer);
7761 }
7762 crate::bindings::InputType::LnUrlWithdraw { data } => {
7763 <i32>::sse_encode(7, serializer);
7764 <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(data, serializer);
7765 }
7766 crate::bindings::InputType::LnUrlAuth { data } => {
7767 <i32>::sse_encode(8, serializer);
7768 <crate::bindings::LnUrlAuthRequestData>::sse_encode(data, serializer);
7769 }
7770 crate::bindings::InputType::LnUrlError { data } => {
7771 <i32>::sse_encode(9, serializer);
7772 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
7773 }
7774 _ => {
7775 unimplemented!("");
7776 }
7777 }
7778 }
7779}
7780
7781impl SseEncode for crate::model::LightningPaymentLimitsResponse {
7782 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7784 <crate::model::Limits>::sse_encode(self.send, serializer);
7785 <crate::model::Limits>::sse_encode(self.receive, serializer);
7786 }
7787}
7788
7789impl SseEncode for crate::model::Limits {
7790 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7792 <u64>::sse_encode(self.min_sat, serializer);
7793 <u64>::sse_encode(self.max_sat, serializer);
7794 <u64>::sse_encode(self.max_zero_conf_sat, serializer);
7795 }
7796}
7797
7798impl SseEncode for crate::bindings::LiquidAddressData {
7799 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7801 <String>::sse_encode(self.address, serializer);
7802 <crate::bindings::Network>::sse_encode(self.network, serializer);
7803 <Option<String>>::sse_encode(self.asset_id, serializer);
7804 <Option<f64>>::sse_encode(self.amount, serializer);
7805 <Option<u64>>::sse_encode(self.amount_sat, serializer);
7806 <Option<String>>::sse_encode(self.label, serializer);
7807 <Option<String>>::sse_encode(self.message, serializer);
7808 }
7809}
7810
7811impl SseEncode for crate::model::LiquidNetwork {
7812 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7814 <i32>::sse_encode(
7815 match self {
7816 crate::model::LiquidNetwork::Mainnet => 0,
7817 crate::model::LiquidNetwork::Testnet => 1,
7818 crate::model::LiquidNetwork::Regtest => 2,
7819 _ => {
7820 unimplemented!("");
7821 }
7822 },
7823 serializer,
7824 );
7825 }
7826}
7827
7828impl SseEncode for Vec<String> {
7829 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7831 <i32>::sse_encode(self.len() as _, serializer);
7832 for item in self {
7833 <String>::sse_encode(item, serializer);
7834 }
7835 }
7836}
7837
7838impl SseEncode for Vec<crate::model::AssetBalance> {
7839 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7841 <i32>::sse_encode(self.len() as _, serializer);
7842 for item in self {
7843 <crate::model::AssetBalance>::sse_encode(item, serializer);
7844 }
7845 }
7846}
7847
7848impl SseEncode for Vec<crate::model::AssetMetadata> {
7849 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7851 <i32>::sse_encode(self.len() as _, serializer);
7852 for item in self {
7853 <crate::model::AssetMetadata>::sse_encode(item, serializer);
7854 }
7855 }
7856}
7857
7858impl SseEncode for Vec<crate::bindings::ExternalInputParser> {
7859 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7861 <i32>::sse_encode(self.len() as _, serializer);
7862 for item in self {
7863 <crate::bindings::ExternalInputParser>::sse_encode(item, serializer);
7864 }
7865 }
7866}
7867
7868impl SseEncode for Vec<crate::bindings::FiatCurrency> {
7869 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7871 <i32>::sse_encode(self.len() as _, serializer);
7872 for item in self {
7873 <crate::bindings::FiatCurrency>::sse_encode(item, serializer);
7874 }
7875 }
7876}
7877
7878impl SseEncode for Vec<crate::bindings::LnOfferBlindedPath> {
7879 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7881 <i32>::sse_encode(self.len() as _, serializer);
7882 for item in self {
7883 <crate::bindings::LnOfferBlindedPath>::sse_encode(item, serializer);
7884 }
7885 }
7886}
7887
7888impl SseEncode for Vec<crate::bindings::LocaleOverrides> {
7889 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7891 <i32>::sse_encode(self.len() as _, serializer);
7892 for item in self {
7893 <crate::bindings::LocaleOverrides>::sse_encode(item, serializer);
7894 }
7895 }
7896}
7897
7898impl SseEncode for Vec<crate::bindings::LocalizedName> {
7899 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7901 <i32>::sse_encode(self.len() as _, serializer);
7902 for item in self {
7903 <crate::bindings::LocalizedName>::sse_encode(item, serializer);
7904 }
7905 }
7906}
7907
7908impl SseEncode for Vec<crate::model::Payment> {
7909 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7911 <i32>::sse_encode(self.len() as _, serializer);
7912 for item in self {
7913 <crate::model::Payment>::sse_encode(item, serializer);
7914 }
7915 }
7916}
7917
7918impl SseEncode for crate::model::ListPaymentDetails {
7919 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7921 match self {
7922 crate::model::ListPaymentDetails::Liquid {
7923 asset_id,
7924 destination,
7925 } => {
7926 <i32>::sse_encode(0, serializer);
7927 <Option<String>>::sse_encode(asset_id, serializer);
7928 <Option<String>>::sse_encode(destination, serializer);
7929 }
7930 crate::model::ListPaymentDetails::Bitcoin { address } => {
7931 <i32>::sse_encode(1, serializer);
7932 <Option<String>>::sse_encode(address, serializer);
7933 }
7934 _ => {
7935 unimplemented!("");
7936 }
7937 }
7938 }
7939}
7940
7941impl SseEncode for Vec<crate::model::PaymentState> {
7942 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7944 <i32>::sse_encode(self.len() as _, serializer);
7945 for item in self {
7946 <crate::model::PaymentState>::sse_encode(item, serializer);
7947 }
7948 }
7949}
7950
7951impl SseEncode for Vec<crate::model::PaymentType> {
7952 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7954 <i32>::sse_encode(self.len() as _, serializer);
7955 for item in self {
7956 <crate::model::PaymentType>::sse_encode(item, serializer);
7957 }
7958 }
7959}
7960
7961impl SseEncode for crate::model::ListPaymentsRequest {
7962 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7964 <Option<Vec<crate::model::PaymentType>>>::sse_encode(self.filters, serializer);
7965 <Option<Vec<crate::model::PaymentState>>>::sse_encode(self.states, serializer);
7966 <Option<i64>>::sse_encode(self.from_timestamp, serializer);
7967 <Option<i64>>::sse_encode(self.to_timestamp, serializer);
7968 <Option<u32>>::sse_encode(self.offset, serializer);
7969 <Option<u32>>::sse_encode(self.limit, serializer);
7970 <Option<crate::model::ListPaymentDetails>>::sse_encode(self.details, serializer);
7971 <Option<bool>>::sse_encode(self.sort_ascending, serializer);
7972 }
7973}
7974
7975impl SseEncode for Vec<u8> {
7976 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7978 <i32>::sse_encode(self.len() as _, serializer);
7979 for item in self {
7980 <u8>::sse_encode(item, serializer);
7981 }
7982 }
7983}
7984
7985impl SseEncode for Vec<crate::bindings::Rate> {
7986 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7988 <i32>::sse_encode(self.len() as _, serializer);
7989 for item in self {
7990 <crate::bindings::Rate>::sse_encode(item, serializer);
7991 }
7992 }
7993}
7994
7995impl SseEncode for Vec<crate::model::RefundableSwap> {
7996 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7998 <i32>::sse_encode(self.len() as _, serializer);
7999 for item in self {
8000 <crate::model::RefundableSwap>::sse_encode(item, serializer);
8001 }
8002 }
8003}
8004
8005impl SseEncode for Vec<crate::bindings::RouteHint> {
8006 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8008 <i32>::sse_encode(self.len() as _, serializer);
8009 for item in self {
8010 <crate::bindings::RouteHint>::sse_encode(item, serializer);
8011 }
8012 }
8013}
8014
8015impl SseEncode for Vec<crate::bindings::RouteHintHop> {
8016 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8018 <i32>::sse_encode(self.len() as _, serializer);
8019 for item in self {
8020 <crate::bindings::RouteHintHop>::sse_encode(item, serializer);
8021 }
8022 }
8023}
8024
8025impl SseEncode for crate::bindings::LNInvoice {
8026 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8028 <String>::sse_encode(self.bolt11, serializer);
8029 <crate::bindings::Network>::sse_encode(self.network, serializer);
8030 <String>::sse_encode(self.payee_pubkey, serializer);
8031 <String>::sse_encode(self.payment_hash, serializer);
8032 <Option<String>>::sse_encode(self.description, serializer);
8033 <Option<String>>::sse_encode(self.description_hash, serializer);
8034 <Option<u64>>::sse_encode(self.amount_msat, serializer);
8035 <u64>::sse_encode(self.timestamp, serializer);
8036 <u64>::sse_encode(self.expiry, serializer);
8037 <Vec<crate::bindings::RouteHint>>::sse_encode(self.routing_hints, serializer);
8038 <Vec<u8>>::sse_encode(self.payment_secret, serializer);
8039 <u64>::sse_encode(self.min_final_cltv_expiry_delta, serializer);
8040 }
8041}
8042
8043impl SseEncode for crate::bindings::LNOffer {
8044 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8046 <String>::sse_encode(self.offer, serializer);
8047 <Vec<String>>::sse_encode(self.chains, serializer);
8048 <Option<crate::bindings::Amount>>::sse_encode(self.min_amount, serializer);
8049 <Option<String>>::sse_encode(self.description, serializer);
8050 <Option<u64>>::sse_encode(self.absolute_expiry, serializer);
8051 <Option<String>>::sse_encode(self.issuer, serializer);
8052 <Option<String>>::sse_encode(self.signing_pubkey, serializer);
8053 <Vec<crate::bindings::LnOfferBlindedPath>>::sse_encode(self.paths, serializer);
8054 }
8055}
8056
8057impl SseEncode for crate::bindings::LnOfferBlindedPath {
8058 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8060 <Vec<String>>::sse_encode(self.blinded_hops, serializer);
8061 }
8062}
8063
8064impl SseEncode for crate::bindings::duplicates::LnUrlAuthError {
8065 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8067 match self {
8068 crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
8069 <i32>::sse_encode(0, serializer);
8070 <String>::sse_encode(err, serializer);
8071 }
8072 crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
8073 <i32>::sse_encode(1, serializer);
8074 <String>::sse_encode(err, serializer);
8075 }
8076 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
8077 <i32>::sse_encode(2, serializer);
8078 <String>::sse_encode(err, serializer);
8079 }
8080 _ => {
8081 unimplemented!("");
8082 }
8083 }
8084 }
8085}
8086
8087impl SseEncode for crate::bindings::LnUrlAuthRequestData {
8088 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8090 <String>::sse_encode(self.k1, serializer);
8091 <Option<String>>::sse_encode(self.action, serializer);
8092 <String>::sse_encode(self.domain, serializer);
8093 <String>::sse_encode(self.url, serializer);
8094 }
8095}
8096
8097impl SseEncode for crate::bindings::duplicates::LnUrlCallbackStatus {
8098 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8100 match self {
8101 crate::bindings::duplicates::LnUrlCallbackStatus::Ok => {
8102 <i32>::sse_encode(0, serializer);
8103 }
8104 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
8105 <i32>::sse_encode(1, serializer);
8106 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8107 }
8108 _ => {
8109 unimplemented!("");
8110 }
8111 }
8112 }
8113}
8114
8115impl SseEncode for crate::bindings::LnUrlErrorData {
8116 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8118 <String>::sse_encode(self.reason, serializer);
8119 }
8120}
8121
8122impl SseEncode for crate::model::LnUrlInfo {
8123 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8125 <Option<String>>::sse_encode(self.ln_address, serializer);
8126 <Option<String>>::sse_encode(self.lnurl_pay_comment, serializer);
8127 <Option<String>>::sse_encode(self.lnurl_pay_domain, serializer);
8128 <Option<String>>::sse_encode(self.lnurl_pay_metadata, serializer);
8129 <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8130 self.lnurl_pay_success_action,
8131 serializer,
8132 );
8133 <Option<crate::bindings::SuccessAction>>::sse_encode(
8134 self.lnurl_pay_unprocessed_success_action,
8135 serializer,
8136 );
8137 <Option<String>>::sse_encode(self.lnurl_withdraw_endpoint, serializer);
8138 }
8139}
8140
8141impl SseEncode for crate::bindings::duplicates::LnUrlPayError {
8142 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8144 match self {
8145 crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => {
8146 <i32>::sse_encode(0, serializer);
8147 }
8148 crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
8149 <i32>::sse_encode(1, serializer);
8150 <String>::sse_encode(err, serializer);
8151 }
8152 crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
8153 <i32>::sse_encode(2, serializer);
8154 <String>::sse_encode(err, serializer);
8155 }
8156 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
8157 <i32>::sse_encode(3, serializer);
8158 <String>::sse_encode(err, serializer);
8159 }
8160 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
8161 <i32>::sse_encode(4, serializer);
8162 <String>::sse_encode(err, serializer);
8163 }
8164 crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
8165 <i32>::sse_encode(5, serializer);
8166 <String>::sse_encode(err, serializer);
8167 }
8168 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
8169 <i32>::sse_encode(6, serializer);
8170 <String>::sse_encode(err, serializer);
8171 }
8172 crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
8173 <i32>::sse_encode(7, serializer);
8174 <String>::sse_encode(err, serializer);
8175 }
8176 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
8177 <i32>::sse_encode(8, serializer);
8178 <String>::sse_encode(err, serializer);
8179 }
8180 crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
8181 <i32>::sse_encode(9, serializer);
8182 <String>::sse_encode(err, serializer);
8183 }
8184 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
8185 <i32>::sse_encode(10, serializer);
8186 <String>::sse_encode(err, serializer);
8187 }
8188 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
8189 <i32>::sse_encode(11, serializer);
8190 <String>::sse_encode(err, serializer);
8191 }
8192 _ => {
8193 unimplemented!("");
8194 }
8195 }
8196 }
8197}
8198
8199impl SseEncode for crate::bindings::LnUrlPayErrorData {
8200 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8202 <String>::sse_encode(self.payment_hash, serializer);
8203 <String>::sse_encode(self.reason, serializer);
8204 }
8205}
8206
8207impl SseEncode for crate::model::LnUrlPayRequest {
8208 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8210 <crate::model::PrepareLnUrlPayResponse>::sse_encode(self.prepare_response, serializer);
8211 }
8212}
8213
8214impl SseEncode for crate::bindings::LnUrlPayRequestData {
8215 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8217 <String>::sse_encode(self.callback, serializer);
8218 <u64>::sse_encode(self.min_sendable, serializer);
8219 <u64>::sse_encode(self.max_sendable, serializer);
8220 <String>::sse_encode(self.metadata_str, serializer);
8221 <u16>::sse_encode(self.comment_allowed, serializer);
8222 <String>::sse_encode(self.domain, serializer);
8223 <bool>::sse_encode(self.allows_nostr, serializer);
8224 <Option<String>>::sse_encode(self.nostr_pubkey, serializer);
8225 <Option<String>>::sse_encode(self.ln_address, serializer);
8226 }
8227}
8228
8229impl SseEncode for crate::model::LnUrlPayResult {
8230 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8232 match self {
8233 crate::model::LnUrlPayResult::EndpointSuccess { data } => {
8234 <i32>::sse_encode(0, serializer);
8235 <crate::model::LnUrlPaySuccessData>::sse_encode(data, serializer);
8236 }
8237 crate::model::LnUrlPayResult::EndpointError { data } => {
8238 <i32>::sse_encode(1, serializer);
8239 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8240 }
8241 crate::model::LnUrlPayResult::PayError { data } => {
8242 <i32>::sse_encode(2, serializer);
8243 <crate::bindings::LnUrlPayErrorData>::sse_encode(data, serializer);
8244 }
8245 _ => {
8246 unimplemented!("");
8247 }
8248 }
8249 }
8250}
8251
8252impl SseEncode for crate::model::LnUrlPaySuccessData {
8253 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8255 <crate::model::Payment>::sse_encode(self.payment, serializer);
8256 <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8257 self.success_action,
8258 serializer,
8259 );
8260 }
8261}
8262
8263impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawError {
8264 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8266 match self {
8267 crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
8268 <i32>::sse_encode(0, serializer);
8269 <String>::sse_encode(err, serializer);
8270 }
8271 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
8272 <i32>::sse_encode(1, serializer);
8273 <String>::sse_encode(err, serializer);
8274 }
8275 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
8276 <i32>::sse_encode(2, serializer);
8277 <String>::sse_encode(err, serializer);
8278 }
8279 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
8280 <i32>::sse_encode(3, serializer);
8281 <String>::sse_encode(err, serializer);
8282 }
8283 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
8284 <i32>::sse_encode(4, serializer);
8285 <String>::sse_encode(err, serializer);
8286 }
8287 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
8288 <i32>::sse_encode(5, serializer);
8289 <String>::sse_encode(err, serializer);
8290 }
8291 _ => {
8292 unimplemented!("");
8293 }
8294 }
8295 }
8296}
8297
8298impl SseEncode for crate::bindings::LnUrlWithdrawRequest {
8299 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8301 <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(self.data, serializer);
8302 <u64>::sse_encode(self.amount_msat, serializer);
8303 <Option<String>>::sse_encode(self.description, serializer);
8304 }
8305}
8306
8307impl SseEncode for crate::bindings::LnUrlWithdrawRequestData {
8308 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8310 <String>::sse_encode(self.callback, serializer);
8311 <String>::sse_encode(self.k1, serializer);
8312 <String>::sse_encode(self.default_description, serializer);
8313 <u64>::sse_encode(self.min_withdrawable, serializer);
8314 <u64>::sse_encode(self.max_withdrawable, serializer);
8315 }
8316}
8317
8318impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawResult {
8319 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8321 match self {
8322 crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
8323 <i32>::sse_encode(0, serializer);
8324 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8325 data, serializer,
8326 );
8327 }
8328 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
8329 <i32>::sse_encode(1, serializer);
8330 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8331 data, serializer,
8332 );
8333 }
8334 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
8335 <i32>::sse_encode(2, serializer);
8336 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8337 }
8338 _ => {
8339 unimplemented!("");
8340 }
8341 }
8342 }
8343}
8344
8345impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
8346 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8348 <crate::bindings::LNInvoice>::sse_encode(self.invoice, serializer);
8349 }
8350}
8351
8352impl SseEncode for crate::bindings::LocaleOverrides {
8353 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8355 <String>::sse_encode(self.locale, serializer);
8356 <Option<u32>>::sse_encode(self.spacing, serializer);
8357 <crate::bindings::Symbol>::sse_encode(self.symbol, serializer);
8358 }
8359}
8360
8361impl SseEncode for crate::bindings::LocalizedName {
8362 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8364 <String>::sse_encode(self.locale, serializer);
8365 <String>::sse_encode(self.name, serializer);
8366 }
8367}
8368
8369impl SseEncode for crate::model::LogEntry {
8370 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8372 <String>::sse_encode(self.line, serializer);
8373 <String>::sse_encode(self.level, serializer);
8374 }
8375}
8376
8377impl SseEncode for crate::bindings::MessageSuccessActionData {
8378 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8380 <String>::sse_encode(self.message, serializer);
8381 }
8382}
8383
8384impl SseEncode for crate::bindings::Network {
8385 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8387 <i32>::sse_encode(
8388 match self {
8389 crate::bindings::Network::Bitcoin => 0,
8390 crate::bindings::Network::Testnet => 1,
8391 crate::bindings::Network::Signet => 2,
8392 crate::bindings::Network::Regtest => 3,
8393 _ => {
8394 unimplemented!("");
8395 }
8396 },
8397 serializer,
8398 );
8399 }
8400}
8401
8402impl SseEncode for crate::model::OnchainPaymentLimitsResponse {
8403 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8405 <crate::model::Limits>::sse_encode(self.send, serializer);
8406 <crate::model::Limits>::sse_encode(self.receive, serializer);
8407 }
8408}
8409
8410impl SseEncode for Option<String> {
8411 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8413 <bool>::sse_encode(self.is_some(), serializer);
8414 if let Some(value) = self {
8415 <String>::sse_encode(value, serializer);
8416 }
8417 }
8418}
8419
8420impl SseEncode for Option<crate::bindings::Amount> {
8421 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8423 <bool>::sse_encode(self.is_some(), serializer);
8424 if let Some(value) = self {
8425 <crate::bindings::Amount>::sse_encode(value, serializer);
8426 }
8427 }
8428}
8429
8430impl SseEncode for Option<crate::model::AssetInfo> {
8431 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8433 <bool>::sse_encode(self.is_some(), serializer);
8434 if let Some(value) = self {
8435 <crate::model::AssetInfo>::sse_encode(value, serializer);
8436 }
8437 }
8438}
8439
8440impl SseEncode for Option<bool> {
8441 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8443 <bool>::sse_encode(self.is_some(), serializer);
8444 if let Some(value) = self {
8445 <bool>::sse_encode(value, serializer);
8446 }
8447 }
8448}
8449
8450impl SseEncode for Option<f64> {
8451 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8453 <bool>::sse_encode(self.is_some(), serializer);
8454 if let Some(value) = self {
8455 <f64>::sse_encode(value, serializer);
8456 }
8457 }
8458}
8459
8460impl SseEncode for Option<i64> {
8461 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8463 <bool>::sse_encode(self.is_some(), serializer);
8464 if let Some(value) = self {
8465 <i64>::sse_encode(value, serializer);
8466 }
8467 }
8468}
8469
8470impl SseEncode for Option<crate::model::ListPaymentDetails> {
8471 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8473 <bool>::sse_encode(self.is_some(), serializer);
8474 if let Some(value) = self {
8475 <crate::model::ListPaymentDetails>::sse_encode(value, serializer);
8476 }
8477 }
8478}
8479
8480impl SseEncode for Option<crate::model::LnUrlInfo> {
8481 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8483 <bool>::sse_encode(self.is_some(), serializer);
8484 if let Some(value) = self {
8485 <crate::model::LnUrlInfo>::sse_encode(value, serializer);
8486 }
8487 }
8488}
8489
8490impl SseEncode for Option<crate::model::PayAmount> {
8491 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8493 <bool>::sse_encode(self.is_some(), serializer);
8494 if let Some(value) = self {
8495 <crate::model::PayAmount>::sse_encode(value, serializer);
8496 }
8497 }
8498}
8499
8500impl SseEncode for Option<crate::model::Payment> {
8501 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8503 <bool>::sse_encode(self.is_some(), serializer);
8504 if let Some(value) = self {
8505 <crate::model::Payment>::sse_encode(value, serializer);
8506 }
8507 }
8508}
8509
8510impl SseEncode for Option<crate::model::ReceiveAmount> {
8511 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8513 <bool>::sse_encode(self.is_some(), serializer);
8514 if let Some(value) = self {
8515 <crate::model::ReceiveAmount>::sse_encode(value, serializer);
8516 }
8517 }
8518}
8519
8520impl SseEncode for Option<crate::bindings::SuccessAction> {
8521 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8523 <bool>::sse_encode(self.is_some(), serializer);
8524 if let Some(value) = self {
8525 <crate::bindings::SuccessAction>::sse_encode(value, serializer);
8526 }
8527 }
8528}
8529
8530impl SseEncode for Option<crate::bindings::SuccessActionProcessed> {
8531 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8533 <bool>::sse_encode(self.is_some(), serializer);
8534 if let Some(value) = self {
8535 <crate::bindings::SuccessActionProcessed>::sse_encode(value, serializer);
8536 }
8537 }
8538}
8539
8540impl SseEncode for Option<crate::bindings::Symbol> {
8541 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8543 <bool>::sse_encode(self.is_some(), serializer);
8544 if let Some(value) = self {
8545 <crate::bindings::Symbol>::sse_encode(value, serializer);
8546 }
8547 }
8548}
8549
8550impl SseEncode for Option<u32> {
8551 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8553 <bool>::sse_encode(self.is_some(), serializer);
8554 if let Some(value) = self {
8555 <u32>::sse_encode(value, serializer);
8556 }
8557 }
8558}
8559
8560impl SseEncode for Option<u64> {
8561 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8563 <bool>::sse_encode(self.is_some(), serializer);
8564 if let Some(value) = self {
8565 <u64>::sse_encode(value, serializer);
8566 }
8567 }
8568}
8569
8570impl SseEncode for Option<Vec<crate::model::AssetMetadata>> {
8571 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8573 <bool>::sse_encode(self.is_some(), serializer);
8574 if let Some(value) = self {
8575 <Vec<crate::model::AssetMetadata>>::sse_encode(value, serializer);
8576 }
8577 }
8578}
8579
8580impl SseEncode for Option<Vec<crate::bindings::ExternalInputParser>> {
8581 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8583 <bool>::sse_encode(self.is_some(), serializer);
8584 if let Some(value) = self {
8585 <Vec<crate::bindings::ExternalInputParser>>::sse_encode(value, serializer);
8586 }
8587 }
8588}
8589
8590impl SseEncode for Option<Vec<crate::model::PaymentState>> {
8591 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8593 <bool>::sse_encode(self.is_some(), serializer);
8594 if let Some(value) = self {
8595 <Vec<crate::model::PaymentState>>::sse_encode(value, serializer);
8596 }
8597 }
8598}
8599
8600impl SseEncode for Option<Vec<crate::model::PaymentType>> {
8601 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8603 <bool>::sse_encode(self.is_some(), serializer);
8604 if let Some(value) = self {
8605 <Vec<crate::model::PaymentType>>::sse_encode(value, serializer);
8606 }
8607 }
8608}
8609
8610impl SseEncode for Option<Vec<u8>> {
8611 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8613 <bool>::sse_encode(self.is_some(), serializer);
8614 if let Some(value) = self {
8615 <Vec<u8>>::sse_encode(value, serializer);
8616 }
8617 }
8618}
8619
8620impl SseEncode for crate::model::PayAmount {
8621 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8623 match self {
8624 crate::model::PayAmount::Bitcoin {
8625 receiver_amount_sat,
8626 } => {
8627 <i32>::sse_encode(0, serializer);
8628 <u64>::sse_encode(receiver_amount_sat, serializer);
8629 }
8630 crate::model::PayAmount::Asset {
8631 asset_id,
8632 receiver_amount,
8633 estimate_asset_fees,
8634 } => {
8635 <i32>::sse_encode(1, serializer);
8636 <String>::sse_encode(asset_id, serializer);
8637 <f64>::sse_encode(receiver_amount, serializer);
8638 <Option<bool>>::sse_encode(estimate_asset_fees, serializer);
8639 }
8640 crate::model::PayAmount::Drain => {
8641 <i32>::sse_encode(2, serializer);
8642 }
8643 _ => {
8644 unimplemented!("");
8645 }
8646 }
8647 }
8648}
8649
8650impl SseEncode for crate::model::PayOnchainRequest {
8651 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8653 <String>::sse_encode(self.address, serializer);
8654 <crate::model::PreparePayOnchainResponse>::sse_encode(self.prepare_response, serializer);
8655 }
8656}
8657
8658impl SseEncode for crate::model::Payment {
8659 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8661 <Option<String>>::sse_encode(self.destination, serializer);
8662 <Option<String>>::sse_encode(self.tx_id, serializer);
8663 <Option<String>>::sse_encode(self.unblinding_data, serializer);
8664 <u32>::sse_encode(self.timestamp, serializer);
8665 <u64>::sse_encode(self.amount_sat, serializer);
8666 <u64>::sse_encode(self.fees_sat, serializer);
8667 <Option<u64>>::sse_encode(self.swapper_fees_sat, serializer);
8668 <crate::model::PaymentType>::sse_encode(self.payment_type, serializer);
8669 <crate::model::PaymentState>::sse_encode(self.status, serializer);
8670 <crate::model::PaymentDetails>::sse_encode(self.details, serializer);
8671 }
8672}
8673
8674impl SseEncode for crate::model::PaymentDetails {
8675 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8677 match self {
8678 crate::model::PaymentDetails::Lightning {
8679 swap_id,
8680 description,
8681 liquid_expiration_blockheight,
8682 preimage,
8683 invoice,
8684 bolt12_offer,
8685 payment_hash,
8686 destination_pubkey,
8687 lnurl_info,
8688 bip353_address,
8689 claim_tx_id,
8690 refund_tx_id,
8691 refund_tx_amount_sat,
8692 } => {
8693 <i32>::sse_encode(0, serializer);
8694 <String>::sse_encode(swap_id, serializer);
8695 <String>::sse_encode(description, serializer);
8696 <u32>::sse_encode(liquid_expiration_blockheight, serializer);
8697 <Option<String>>::sse_encode(preimage, serializer);
8698 <Option<String>>::sse_encode(invoice, serializer);
8699 <Option<String>>::sse_encode(bolt12_offer, serializer);
8700 <Option<String>>::sse_encode(payment_hash, serializer);
8701 <Option<String>>::sse_encode(destination_pubkey, serializer);
8702 <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8703 <Option<String>>::sse_encode(bip353_address, serializer);
8704 <Option<String>>::sse_encode(claim_tx_id, serializer);
8705 <Option<String>>::sse_encode(refund_tx_id, serializer);
8706 <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8707 }
8708 crate::model::PaymentDetails::Liquid {
8709 destination,
8710 description,
8711 asset_id,
8712 asset_info,
8713 lnurl_info,
8714 bip353_address,
8715 } => {
8716 <i32>::sse_encode(1, serializer);
8717 <String>::sse_encode(destination, serializer);
8718 <String>::sse_encode(description, serializer);
8719 <String>::sse_encode(asset_id, serializer);
8720 <Option<crate::model::AssetInfo>>::sse_encode(asset_info, serializer);
8721 <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8722 <Option<String>>::sse_encode(bip353_address, serializer);
8723 }
8724 crate::model::PaymentDetails::Bitcoin {
8725 swap_id,
8726 description,
8727 auto_accepted_fees,
8728 liquid_expiration_blockheight,
8729 bitcoin_expiration_blockheight,
8730 claim_tx_id,
8731 refund_tx_id,
8732 refund_tx_amount_sat,
8733 } => {
8734 <i32>::sse_encode(2, serializer);
8735 <String>::sse_encode(swap_id, serializer);
8736 <String>::sse_encode(description, serializer);
8737 <bool>::sse_encode(auto_accepted_fees, serializer);
8738 <Option<u32>>::sse_encode(liquid_expiration_blockheight, serializer);
8739 <Option<u32>>::sse_encode(bitcoin_expiration_blockheight, serializer);
8740 <Option<String>>::sse_encode(claim_tx_id, serializer);
8741 <Option<String>>::sse_encode(refund_tx_id, serializer);
8742 <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8743 }
8744 _ => {
8745 unimplemented!("");
8746 }
8747 }
8748 }
8749}
8750
8751impl SseEncode for crate::error::PaymentError {
8752 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8754 match self {
8755 crate::error::PaymentError::AlreadyClaimed => {
8756 <i32>::sse_encode(0, serializer);
8757 }
8758 crate::error::PaymentError::AlreadyPaid => {
8759 <i32>::sse_encode(1, serializer);
8760 }
8761 crate::error::PaymentError::PaymentInProgress => {
8762 <i32>::sse_encode(2, serializer);
8763 }
8764 crate::error::PaymentError::AmountOutOfRange => {
8765 <i32>::sse_encode(3, serializer);
8766 }
8767 crate::error::PaymentError::AmountMissing { err } => {
8768 <i32>::sse_encode(4, serializer);
8769 <String>::sse_encode(err, serializer);
8770 }
8771 crate::error::PaymentError::AssetError { err } => {
8772 <i32>::sse_encode(5, serializer);
8773 <String>::sse_encode(err, serializer);
8774 }
8775 crate::error::PaymentError::InvalidNetwork { err } => {
8776 <i32>::sse_encode(6, serializer);
8777 <String>::sse_encode(err, serializer);
8778 }
8779 crate::error::PaymentError::Generic { err } => {
8780 <i32>::sse_encode(7, serializer);
8781 <String>::sse_encode(err, serializer);
8782 }
8783 crate::error::PaymentError::InvalidOrExpiredFees => {
8784 <i32>::sse_encode(8, serializer);
8785 }
8786 crate::error::PaymentError::InsufficientFunds => {
8787 <i32>::sse_encode(9, serializer);
8788 }
8789 crate::error::PaymentError::InvalidDescription { err } => {
8790 <i32>::sse_encode(10, serializer);
8791 <String>::sse_encode(err, serializer);
8792 }
8793 crate::error::PaymentError::InvalidInvoice { err } => {
8794 <i32>::sse_encode(11, serializer);
8795 <String>::sse_encode(err, serializer);
8796 }
8797 crate::error::PaymentError::InvalidPreimage => {
8798 <i32>::sse_encode(12, serializer);
8799 }
8800 crate::error::PaymentError::PairsNotFound => {
8801 <i32>::sse_encode(13, serializer);
8802 }
8803 crate::error::PaymentError::PaymentTimeout => {
8804 <i32>::sse_encode(14, serializer);
8805 }
8806 crate::error::PaymentError::PersistError => {
8807 <i32>::sse_encode(15, serializer);
8808 }
8809 crate::error::PaymentError::ReceiveError { err } => {
8810 <i32>::sse_encode(16, serializer);
8811 <String>::sse_encode(err, serializer);
8812 }
8813 crate::error::PaymentError::Refunded { err, refund_tx_id } => {
8814 <i32>::sse_encode(17, serializer);
8815 <String>::sse_encode(err, serializer);
8816 <String>::sse_encode(refund_tx_id, serializer);
8817 }
8818 crate::error::PaymentError::SelfTransferNotSupported => {
8819 <i32>::sse_encode(18, serializer);
8820 }
8821 crate::error::PaymentError::SendError { err } => {
8822 <i32>::sse_encode(19, serializer);
8823 <String>::sse_encode(err, serializer);
8824 }
8825 crate::error::PaymentError::SignerError { err } => {
8826 <i32>::sse_encode(20, serializer);
8827 <String>::sse_encode(err, serializer);
8828 }
8829 _ => {
8830 unimplemented!("");
8831 }
8832 }
8833 }
8834}
8835
8836impl SseEncode for crate::model::PaymentMethod {
8837 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8839 <i32>::sse_encode(
8840 match self {
8841 crate::model::PaymentMethod::Lightning => 0,
8842 crate::model::PaymentMethod::BitcoinAddress => 1,
8843 crate::model::PaymentMethod::LiquidAddress => 2,
8844 _ => {
8845 unimplemented!("");
8846 }
8847 },
8848 serializer,
8849 );
8850 }
8851}
8852
8853impl SseEncode for crate::model::PaymentState {
8854 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8856 <i32>::sse_encode(
8857 match self {
8858 crate::model::PaymentState::Created => 0,
8859 crate::model::PaymentState::Pending => 1,
8860 crate::model::PaymentState::Complete => 2,
8861 crate::model::PaymentState::Failed => 3,
8862 crate::model::PaymentState::TimedOut => 4,
8863 crate::model::PaymentState::Refundable => 5,
8864 crate::model::PaymentState::RefundPending => 6,
8865 crate::model::PaymentState::WaitingFeeAcceptance => 7,
8866 _ => {
8867 unimplemented!("");
8868 }
8869 },
8870 serializer,
8871 );
8872 }
8873}
8874
8875impl SseEncode for crate::model::PaymentType {
8876 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8878 <i32>::sse_encode(
8879 match self {
8880 crate::model::PaymentType::Receive => 0,
8881 crate::model::PaymentType::Send => 1,
8882 _ => {
8883 unimplemented!("");
8884 }
8885 },
8886 serializer,
8887 );
8888 }
8889}
8890
8891impl SseEncode for crate::model::PrepareBuyBitcoinRequest {
8892 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8894 <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
8895 <u64>::sse_encode(self.amount_sat, serializer);
8896 }
8897}
8898
8899impl SseEncode for crate::model::PrepareBuyBitcoinResponse {
8900 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8902 <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
8903 <u64>::sse_encode(self.amount_sat, serializer);
8904 <u64>::sse_encode(self.fees_sat, serializer);
8905 }
8906}
8907
8908impl SseEncode for crate::model::PrepareLnUrlPayRequest {
8909 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8911 <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
8912 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
8913 <Option<String>>::sse_encode(self.bip353_address, serializer);
8914 <Option<String>>::sse_encode(self.comment, serializer);
8915 <Option<bool>>::sse_encode(self.validate_success_action_url, serializer);
8916 }
8917}
8918
8919impl SseEncode for crate::model::PrepareLnUrlPayResponse {
8920 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8922 <crate::model::SendDestination>::sse_encode(self.destination, serializer);
8923 <u64>::sse_encode(self.fees_sat, serializer);
8924 <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
8925 <Option<String>>::sse_encode(self.comment, serializer);
8926 <Option<crate::bindings::SuccessAction>>::sse_encode(self.success_action, serializer);
8927 }
8928}
8929
8930impl SseEncode for crate::model::PreparePayOnchainRequest {
8931 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8933 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
8934 <Option<u32>>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
8935 }
8936}
8937
8938impl SseEncode for crate::model::PreparePayOnchainResponse {
8939 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8941 <u64>::sse_encode(self.receiver_amount_sat, serializer);
8942 <u64>::sse_encode(self.claim_fees_sat, serializer);
8943 <u64>::sse_encode(self.total_fees_sat, serializer);
8944 }
8945}
8946
8947impl SseEncode for crate::model::PrepareReceiveRequest {
8948 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8950 <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
8951 <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
8952 }
8953}
8954
8955impl SseEncode for crate::model::PrepareReceiveResponse {
8956 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8958 <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
8959 <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
8960 <u64>::sse_encode(self.fees_sat, serializer);
8961 <Option<u64>>::sse_encode(self.min_payer_amount_sat, serializer);
8962 <Option<u64>>::sse_encode(self.max_payer_amount_sat, serializer);
8963 <Option<f64>>::sse_encode(self.swapper_feerate, serializer);
8964 }
8965}
8966
8967impl SseEncode for crate::model::PrepareRefundRequest {
8968 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8970 <String>::sse_encode(self.swap_address, serializer);
8971 <String>::sse_encode(self.refund_address, serializer);
8972 <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
8973 }
8974}
8975
8976impl SseEncode for crate::model::PrepareRefundResponse {
8977 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8979 <u32>::sse_encode(self.tx_vsize, serializer);
8980 <u64>::sse_encode(self.tx_fee_sat, serializer);
8981 <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
8982 }
8983}
8984
8985impl SseEncode for crate::model::PrepareSendRequest {
8986 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8988 <String>::sse_encode(self.destination, serializer);
8989 <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
8990 }
8991}
8992
8993impl SseEncode for crate::model::PrepareSendResponse {
8994 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8996 <crate::model::SendDestination>::sse_encode(self.destination, serializer);
8997 <Option<u64>>::sse_encode(self.fees_sat, serializer);
8998 <Option<f64>>::sse_encode(self.estimated_asset_fees, serializer);
8999 }
9000}
9001
9002impl SseEncode for crate::bindings::Rate {
9003 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9005 <String>::sse_encode(self.coin, serializer);
9006 <f64>::sse_encode(self.value, serializer);
9007 }
9008}
9009
9010impl SseEncode for crate::model::ReceiveAmount {
9011 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9013 match self {
9014 crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
9015 <i32>::sse_encode(0, serializer);
9016 <u64>::sse_encode(payer_amount_sat, serializer);
9017 }
9018 crate::model::ReceiveAmount::Asset {
9019 asset_id,
9020 payer_amount,
9021 } => {
9022 <i32>::sse_encode(1, serializer);
9023 <String>::sse_encode(asset_id, serializer);
9024 <Option<f64>>::sse_encode(payer_amount, serializer);
9025 }
9026 _ => {
9027 unimplemented!("");
9028 }
9029 }
9030 }
9031}
9032
9033impl SseEncode for crate::model::ReceivePaymentRequest {
9034 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9036 <crate::model::PrepareReceiveResponse>::sse_encode(self.prepare_response, serializer);
9037 <Option<String>>::sse_encode(self.description, serializer);
9038 <Option<bool>>::sse_encode(self.use_description_hash, serializer);
9039 }
9040}
9041
9042impl SseEncode for crate::model::ReceivePaymentResponse {
9043 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9045 <String>::sse_encode(self.destination, serializer);
9046 }
9047}
9048
9049impl SseEncode for crate::model::RecommendedFees {
9050 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9052 <u64>::sse_encode(self.fastest_fee, serializer);
9053 <u64>::sse_encode(self.half_hour_fee, serializer);
9054 <u64>::sse_encode(self.hour_fee, serializer);
9055 <u64>::sse_encode(self.economy_fee, serializer);
9056 <u64>::sse_encode(self.minimum_fee, serializer);
9057 }
9058}
9059
9060impl SseEncode for crate::model::RefundRequest {
9061 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9063 <String>::sse_encode(self.swap_address, serializer);
9064 <String>::sse_encode(self.refund_address, serializer);
9065 <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9066 }
9067}
9068
9069impl SseEncode for crate::model::RefundResponse {
9070 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9072 <String>::sse_encode(self.refund_tx_id, serializer);
9073 }
9074}
9075
9076impl SseEncode for crate::model::RefundableSwap {
9077 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9079 <String>::sse_encode(self.swap_address, serializer);
9080 <u32>::sse_encode(self.timestamp, serializer);
9081 <u64>::sse_encode(self.amount_sat, serializer);
9082 <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9083 }
9084}
9085
9086impl SseEncode for crate::model::RestoreRequest {
9087 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9089 <Option<String>>::sse_encode(self.backup_path, serializer);
9090 }
9091}
9092
9093impl SseEncode for crate::bindings::RouteHint {
9094 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9096 <Vec<crate::bindings::RouteHintHop>>::sse_encode(self.hops, serializer);
9097 }
9098}
9099
9100impl SseEncode for crate::bindings::RouteHintHop {
9101 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9103 <String>::sse_encode(self.src_node_id, serializer);
9104 <String>::sse_encode(self.short_channel_id, serializer);
9105 <u32>::sse_encode(self.fees_base_msat, serializer);
9106 <u32>::sse_encode(self.fees_proportional_millionths, serializer);
9107 <u64>::sse_encode(self.cltv_expiry_delta, serializer);
9108 <Option<u64>>::sse_encode(self.htlc_minimum_msat, serializer);
9109 <Option<u64>>::sse_encode(self.htlc_maximum_msat, serializer);
9110 }
9111}
9112
9113impl SseEncode for crate::error::SdkError {
9114 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9116 match self {
9117 crate::error::SdkError::AlreadyStarted => {
9118 <i32>::sse_encode(0, serializer);
9119 }
9120 crate::error::SdkError::Generic { err } => {
9121 <i32>::sse_encode(1, serializer);
9122 <String>::sse_encode(err, serializer);
9123 }
9124 crate::error::SdkError::NotStarted => {
9125 <i32>::sse_encode(2, serializer);
9126 }
9127 crate::error::SdkError::ServiceConnectivity { err } => {
9128 <i32>::sse_encode(3, serializer);
9129 <String>::sse_encode(err, serializer);
9130 }
9131 _ => {
9132 unimplemented!("");
9133 }
9134 }
9135 }
9136}
9137
9138impl SseEncode for crate::model::SdkEvent {
9139 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9141 match self {
9142 crate::model::SdkEvent::PaymentFailed { details } => {
9143 <i32>::sse_encode(0, serializer);
9144 <crate::model::Payment>::sse_encode(details, serializer);
9145 }
9146 crate::model::SdkEvent::PaymentPending { details } => {
9147 <i32>::sse_encode(1, serializer);
9148 <crate::model::Payment>::sse_encode(details, serializer);
9149 }
9150 crate::model::SdkEvent::PaymentRefundable { details } => {
9151 <i32>::sse_encode(2, serializer);
9152 <crate::model::Payment>::sse_encode(details, serializer);
9153 }
9154 crate::model::SdkEvent::PaymentRefunded { details } => {
9155 <i32>::sse_encode(3, serializer);
9156 <crate::model::Payment>::sse_encode(details, serializer);
9157 }
9158 crate::model::SdkEvent::PaymentRefundPending { details } => {
9159 <i32>::sse_encode(4, serializer);
9160 <crate::model::Payment>::sse_encode(details, serializer);
9161 }
9162 crate::model::SdkEvent::PaymentSucceeded { details } => {
9163 <i32>::sse_encode(5, serializer);
9164 <crate::model::Payment>::sse_encode(details, serializer);
9165 }
9166 crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
9167 <i32>::sse_encode(6, serializer);
9168 <crate::model::Payment>::sse_encode(details, serializer);
9169 }
9170 crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
9171 <i32>::sse_encode(7, serializer);
9172 <crate::model::Payment>::sse_encode(details, serializer);
9173 }
9174 crate::model::SdkEvent::Synced => {
9175 <i32>::sse_encode(8, serializer);
9176 }
9177 crate::model::SdkEvent::DataSynced {
9178 did_pull_new_records,
9179 } => {
9180 <i32>::sse_encode(9, serializer);
9181 <bool>::sse_encode(did_pull_new_records, serializer);
9182 }
9183 _ => {
9184 unimplemented!("");
9185 }
9186 }
9187 }
9188}
9189
9190impl SseEncode for crate::model::SendDestination {
9191 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9193 match self {
9194 crate::model::SendDestination::LiquidAddress {
9195 address_data,
9196 bip353_address,
9197 } => {
9198 <i32>::sse_encode(0, serializer);
9199 <crate::bindings::LiquidAddressData>::sse_encode(address_data, serializer);
9200 <Option<String>>::sse_encode(bip353_address, serializer);
9201 }
9202 crate::model::SendDestination::Bolt11 {
9203 invoice,
9204 bip353_address,
9205 } => {
9206 <i32>::sse_encode(1, serializer);
9207 <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
9208 <Option<String>>::sse_encode(bip353_address, serializer);
9209 }
9210 crate::model::SendDestination::Bolt12 {
9211 offer,
9212 receiver_amount_sat,
9213 bip353_address,
9214 } => {
9215 <i32>::sse_encode(2, serializer);
9216 <crate::bindings::LNOffer>::sse_encode(offer, serializer);
9217 <u64>::sse_encode(receiver_amount_sat, serializer);
9218 <Option<String>>::sse_encode(bip353_address, serializer);
9219 }
9220 _ => {
9221 unimplemented!("");
9222 }
9223 }
9224 }
9225}
9226
9227impl SseEncode for crate::model::SendPaymentRequest {
9228 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9230 <crate::model::PrepareSendResponse>::sse_encode(self.prepare_response, serializer);
9231 <Option<bool>>::sse_encode(self.use_asset_fees, serializer);
9232 }
9233}
9234
9235impl SseEncode for crate::model::SendPaymentResponse {
9236 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9238 <crate::model::Payment>::sse_encode(self.payment, serializer);
9239 }
9240}
9241
9242impl SseEncode for crate::model::SignMessageRequest {
9243 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9245 <String>::sse_encode(self.message, serializer);
9246 }
9247}
9248
9249impl SseEncode for crate::model::SignMessageResponse {
9250 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9252 <String>::sse_encode(self.signature, serializer);
9253 }
9254}
9255
9256impl SseEncode for crate::bindings::SuccessAction {
9257 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9259 match self {
9260 crate::bindings::SuccessAction::Aes { data } => {
9261 <i32>::sse_encode(0, serializer);
9262 <crate::bindings::AesSuccessActionData>::sse_encode(data, serializer);
9263 }
9264 crate::bindings::SuccessAction::Message { data } => {
9265 <i32>::sse_encode(1, serializer);
9266 <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9267 }
9268 crate::bindings::SuccessAction::Url { data } => {
9269 <i32>::sse_encode(2, serializer);
9270 <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9271 }
9272 _ => {
9273 unimplemented!("");
9274 }
9275 }
9276 }
9277}
9278
9279impl SseEncode for crate::bindings::SuccessActionProcessed {
9280 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9282 match self {
9283 crate::bindings::SuccessActionProcessed::Aes { result } => {
9284 <i32>::sse_encode(0, serializer);
9285 <crate::bindings::AesSuccessActionDataResult>::sse_encode(result, serializer);
9286 }
9287 crate::bindings::SuccessActionProcessed::Message { data } => {
9288 <i32>::sse_encode(1, serializer);
9289 <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9290 }
9291 crate::bindings::SuccessActionProcessed::Url { data } => {
9292 <i32>::sse_encode(2, serializer);
9293 <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9294 }
9295 _ => {
9296 unimplemented!("");
9297 }
9298 }
9299 }
9300}
9301
9302impl SseEncode for crate::bindings::Symbol {
9303 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9305 <Option<String>>::sse_encode(self.grapheme, serializer);
9306 <Option<String>>::sse_encode(self.template, serializer);
9307 <Option<bool>>::sse_encode(self.rtl, serializer);
9308 <Option<u32>>::sse_encode(self.position, serializer);
9309 }
9310}
9311
9312impl SseEncode for u16 {
9313 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9315 serializer.cursor.write_u16::<NativeEndian>(self).unwrap();
9316 }
9317}
9318
9319impl SseEncode for u32 {
9320 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9322 serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
9323 }
9324}
9325
9326impl SseEncode for u64 {
9327 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9329 serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
9330 }
9331}
9332
9333impl SseEncode for u8 {
9334 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9336 serializer.cursor.write_u8(self).unwrap();
9337 }
9338}
9339
9340impl SseEncode for () {
9341 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
9343}
9344
9345impl SseEncode for crate::bindings::UrlSuccessActionData {
9346 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9348 <String>::sse_encode(self.description, serializer);
9349 <String>::sse_encode(self.url, serializer);
9350 <bool>::sse_encode(self.matches_callback_domain, serializer);
9351 }
9352}
9353
9354impl SseEncode for usize {
9355 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9357 serializer
9358 .cursor
9359 .write_u64::<NativeEndian>(self as _)
9360 .unwrap();
9361 }
9362}
9363
9364impl SseEncode for crate::model::WalletInfo {
9365 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9367 <u64>::sse_encode(self.balance_sat, serializer);
9368 <u64>::sse_encode(self.pending_send_sat, serializer);
9369 <u64>::sse_encode(self.pending_receive_sat, serializer);
9370 <String>::sse_encode(self.fingerprint, serializer);
9371 <String>::sse_encode(self.pubkey, serializer);
9372 <Vec<crate::model::AssetBalance>>::sse_encode(self.asset_balances, serializer);
9373 }
9374}
9375
9376#[cfg(not(target_family = "wasm"))]
9377mod io {
9378 use super::*;
9384 use crate::bindings::*;
9385 use crate::model::EventListener;
9386 use flutter_rust_bridge::for_generated::byteorder::{
9387 NativeEndian, ReadBytesExt, WriteBytesExt,
9388 };
9389 use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
9390 use flutter_rust_bridge::{Handler, IntoIntoDart};
9391
9392 flutter_rust_bridge::frb_generated_boilerplate_io!();
9395
9396 impl CstDecode<flutter_rust_bridge::for_generated::anyhow::Error>
9399 for *mut wire_cst_list_prim_u_8_strict
9400 {
9401 fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error {
9403 unimplemented!()
9404 }
9405 }
9406 impl CstDecode<BindingLiquidSdk> for usize {
9407 fn cst_decode(self) -> BindingLiquidSdk {
9409 flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::<
9410 RustOpaqueNom<
9411 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9412 >,
9413 >::cst_decode(
9414 self
9415 ))
9416 }
9417 }
9418 impl
9419 CstDecode<
9420 RustOpaqueNom<
9421 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9422 >,
9423 > for usize
9424 {
9425 fn cst_decode(
9427 self,
9428 ) -> RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
9429 {
9430 unsafe { decode_rust_opaque_nom(self as _) }
9431 }
9432 }
9433 impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>
9434 for *mut wire_cst_list_prim_u_8_strict
9435 {
9436 fn cst_decode(
9438 self,
9439 ) -> StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
9440 {
9441 let raw: String = self.cst_decode();
9442 StreamSink::deserialize(raw)
9443 }
9444 }
9445 impl CstDecode<StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>>
9446 for *mut wire_cst_list_prim_u_8_strict
9447 {
9448 fn cst_decode(
9450 self,
9451 ) -> StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
9452 {
9453 let raw: String = self.cst_decode();
9454 StreamSink::deserialize(raw)
9455 }
9456 }
9457 impl CstDecode<String> for *mut wire_cst_list_prim_u_8_strict {
9458 fn cst_decode(self) -> String {
9460 let vec: Vec<u8> = self.cst_decode();
9461 String::from_utf8(vec).unwrap()
9462 }
9463 }
9464 impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9465 for wire_cst_accept_payment_proposed_fees_request
9466 {
9467 fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9469 crate::model::AcceptPaymentProposedFeesRequest {
9470 response: self.response.cst_decode(),
9471 }
9472 }
9473 }
9474 impl CstDecode<crate::bindings::AesSuccessActionData> for wire_cst_aes_success_action_data {
9475 fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9477 crate::bindings::AesSuccessActionData {
9478 description: self.description.cst_decode(),
9479 ciphertext: self.ciphertext.cst_decode(),
9480 iv: self.iv.cst_decode(),
9481 }
9482 }
9483 }
9484 impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9485 for wire_cst_aes_success_action_data_decrypted
9486 {
9487 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9489 crate::bindings::AesSuccessActionDataDecrypted {
9490 description: self.description.cst_decode(),
9491 plaintext: self.plaintext.cst_decode(),
9492 }
9493 }
9494 }
9495 impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9496 for wire_cst_aes_success_action_data_result
9497 {
9498 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9500 match self.tag {
9501 0 => {
9502 let ans = unsafe { self.kind.Decrypted };
9503 crate::bindings::AesSuccessActionDataResult::Decrypted {
9504 data: ans.data.cst_decode(),
9505 }
9506 }
9507 1 => {
9508 let ans = unsafe { self.kind.ErrorStatus };
9509 crate::bindings::AesSuccessActionDataResult::ErrorStatus {
9510 reason: ans.reason.cst_decode(),
9511 }
9512 }
9513 _ => unreachable!(),
9514 }
9515 }
9516 }
9517 impl CstDecode<crate::bindings::Amount> for wire_cst_amount {
9518 fn cst_decode(self) -> crate::bindings::Amount {
9520 match self.tag {
9521 0 => {
9522 let ans = unsafe { self.kind.Bitcoin };
9523 crate::bindings::Amount::Bitcoin {
9524 amount_msat: ans.amount_msat.cst_decode(),
9525 }
9526 }
9527 1 => {
9528 let ans = unsafe { self.kind.Currency };
9529 crate::bindings::Amount::Currency {
9530 iso4217_code: ans.iso4217_code.cst_decode(),
9531 fractional_amount: ans.fractional_amount.cst_decode(),
9532 }
9533 }
9534 _ => unreachable!(),
9535 }
9536 }
9537 }
9538 impl CstDecode<crate::model::AssetBalance> for wire_cst_asset_balance {
9539 fn cst_decode(self) -> crate::model::AssetBalance {
9541 crate::model::AssetBalance {
9542 asset_id: self.asset_id.cst_decode(),
9543 balance_sat: self.balance_sat.cst_decode(),
9544 name: self.name.cst_decode(),
9545 ticker: self.ticker.cst_decode(),
9546 balance: self.balance.cst_decode(),
9547 }
9548 }
9549 }
9550 impl CstDecode<crate::model::AssetInfo> for wire_cst_asset_info {
9551 fn cst_decode(self) -> crate::model::AssetInfo {
9553 crate::model::AssetInfo {
9554 name: self.name.cst_decode(),
9555 ticker: self.ticker.cst_decode(),
9556 amount: self.amount.cst_decode(),
9557 fees: self.fees.cst_decode(),
9558 }
9559 }
9560 }
9561 impl CstDecode<crate::model::AssetMetadata> for wire_cst_asset_metadata {
9562 fn cst_decode(self) -> crate::model::AssetMetadata {
9564 crate::model::AssetMetadata {
9565 asset_id: self.asset_id.cst_decode(),
9566 name: self.name.cst_decode(),
9567 ticker: self.ticker.cst_decode(),
9568 precision: self.precision.cst_decode(),
9569 fiat_id: self.fiat_id.cst_decode(),
9570 }
9571 }
9572 }
9573 impl CstDecode<crate::model::BackupRequest> for wire_cst_backup_request {
9574 fn cst_decode(self) -> crate::model::BackupRequest {
9576 crate::model::BackupRequest {
9577 backup_path: self.backup_path.cst_decode(),
9578 }
9579 }
9580 }
9581 impl CstDecode<crate::bindings::BindingEventListener> for wire_cst_binding_event_listener {
9582 fn cst_decode(self) -> crate::bindings::BindingEventListener {
9584 crate::bindings::BindingEventListener {
9585 stream: self.stream.cst_decode(),
9586 }
9587 }
9588 }
9589 impl CstDecode<crate::bindings::BitcoinAddressData> for wire_cst_bitcoin_address_data {
9590 fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9592 crate::bindings::BitcoinAddressData {
9593 address: self.address.cst_decode(),
9594 network: self.network.cst_decode(),
9595 amount_sat: self.amount_sat.cst_decode(),
9596 label: self.label.cst_decode(),
9597 message: self.message.cst_decode(),
9598 }
9599 }
9600 }
9601 impl CstDecode<crate::model::BlockchainExplorer> for wire_cst_blockchain_explorer {
9602 fn cst_decode(self) -> crate::model::BlockchainExplorer {
9604 match self.tag {
9605 0 => {
9606 let ans = unsafe { self.kind.Electrum };
9607 crate::model::BlockchainExplorer::Electrum {
9608 url: ans.url.cst_decode(),
9609 }
9610 }
9611 1 => {
9612 let ans = unsafe { self.kind.Esplora };
9613 crate::model::BlockchainExplorer::Esplora {
9614 url: ans.url.cst_decode(),
9615 use_waterfalls: ans.use_waterfalls.cst_decode(),
9616 }
9617 }
9618 _ => unreachable!(),
9619 }
9620 }
9621 }
9622 impl CstDecode<crate::model::BlockchainInfo> for wire_cst_blockchain_info {
9623 fn cst_decode(self) -> crate::model::BlockchainInfo {
9625 crate::model::BlockchainInfo {
9626 liquid_tip: self.liquid_tip.cst_decode(),
9627 bitcoin_tip: self.bitcoin_tip.cst_decode(),
9628 }
9629 }
9630 }
9631 impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9632 for *mut wire_cst_accept_payment_proposed_fees_request
9633 {
9634 fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9636 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9637 CstDecode::<crate::model::AcceptPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9638 }
9639 }
9640 impl CstDecode<crate::bindings::AesSuccessActionData> for *mut wire_cst_aes_success_action_data {
9641 fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9643 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9644 CstDecode::<crate::bindings::AesSuccessActionData>::cst_decode(*wrap).into()
9645 }
9646 }
9647 impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9648 for *mut wire_cst_aes_success_action_data_decrypted
9649 {
9650 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9652 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9653 CstDecode::<crate::bindings::AesSuccessActionDataDecrypted>::cst_decode(*wrap).into()
9654 }
9655 }
9656 impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9657 for *mut wire_cst_aes_success_action_data_result
9658 {
9659 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9661 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9662 CstDecode::<crate::bindings::AesSuccessActionDataResult>::cst_decode(*wrap).into()
9663 }
9664 }
9665 impl CstDecode<crate::bindings::Amount> for *mut wire_cst_amount {
9666 fn cst_decode(self) -> crate::bindings::Amount {
9668 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9669 CstDecode::<crate::bindings::Amount>::cst_decode(*wrap).into()
9670 }
9671 }
9672 impl CstDecode<crate::model::AssetInfo> for *mut wire_cst_asset_info {
9673 fn cst_decode(self) -> crate::model::AssetInfo {
9675 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9676 CstDecode::<crate::model::AssetInfo>::cst_decode(*wrap).into()
9677 }
9678 }
9679 impl CstDecode<crate::model::BackupRequest> for *mut wire_cst_backup_request {
9680 fn cst_decode(self) -> crate::model::BackupRequest {
9682 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9683 CstDecode::<crate::model::BackupRequest>::cst_decode(*wrap).into()
9684 }
9685 }
9686 impl CstDecode<crate::bindings::BindingEventListener> for *mut wire_cst_binding_event_listener {
9687 fn cst_decode(self) -> crate::bindings::BindingEventListener {
9689 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9690 CstDecode::<crate::bindings::BindingEventListener>::cst_decode(*wrap).into()
9691 }
9692 }
9693 impl CstDecode<crate::bindings::BitcoinAddressData> for *mut wire_cst_bitcoin_address_data {
9694 fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9696 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9697 CstDecode::<crate::bindings::BitcoinAddressData>::cst_decode(*wrap).into()
9698 }
9699 }
9700 impl CstDecode<bool> for *mut bool {
9701 fn cst_decode(self) -> bool {
9703 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9704 }
9705 }
9706 impl CstDecode<crate::model::BuyBitcoinRequest> for *mut wire_cst_buy_bitcoin_request {
9707 fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
9709 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9710 CstDecode::<crate::model::BuyBitcoinRequest>::cst_decode(*wrap).into()
9711 }
9712 }
9713 impl CstDecode<crate::model::CheckMessageRequest> for *mut wire_cst_check_message_request {
9714 fn cst_decode(self) -> crate::model::CheckMessageRequest {
9716 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9717 CstDecode::<crate::model::CheckMessageRequest>::cst_decode(*wrap).into()
9718 }
9719 }
9720 impl CstDecode<crate::model::ConnectRequest> for *mut wire_cst_connect_request {
9721 fn cst_decode(self) -> crate::model::ConnectRequest {
9723 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9724 CstDecode::<crate::model::ConnectRequest>::cst_decode(*wrap).into()
9725 }
9726 }
9727 impl CstDecode<f64> for *mut f64 {
9728 fn cst_decode(self) -> f64 {
9730 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9731 }
9732 }
9733 impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
9734 for *mut wire_cst_fetch_payment_proposed_fees_request
9735 {
9736 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
9738 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9739 CstDecode::<crate::model::FetchPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9740 }
9741 }
9742 impl CstDecode<crate::model::GetPaymentRequest> for *mut wire_cst_get_payment_request {
9743 fn cst_decode(self) -> crate::model::GetPaymentRequest {
9745 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9746 CstDecode::<crate::model::GetPaymentRequest>::cst_decode(*wrap).into()
9747 }
9748 }
9749 impl CstDecode<i64> for *mut i64 {
9750 fn cst_decode(self) -> i64 {
9752 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9753 }
9754 }
9755 impl CstDecode<crate::bindings::LiquidAddressData> for *mut wire_cst_liquid_address_data {
9756 fn cst_decode(self) -> crate::bindings::LiquidAddressData {
9758 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9759 CstDecode::<crate::bindings::LiquidAddressData>::cst_decode(*wrap).into()
9760 }
9761 }
9762 impl CstDecode<crate::model::ListPaymentDetails> for *mut wire_cst_list_payment_details {
9763 fn cst_decode(self) -> crate::model::ListPaymentDetails {
9765 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9766 CstDecode::<crate::model::ListPaymentDetails>::cst_decode(*wrap).into()
9767 }
9768 }
9769 impl CstDecode<crate::model::ListPaymentsRequest> for *mut wire_cst_list_payments_request {
9770 fn cst_decode(self) -> crate::model::ListPaymentsRequest {
9772 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9773 CstDecode::<crate::model::ListPaymentsRequest>::cst_decode(*wrap).into()
9774 }
9775 }
9776 impl CstDecode<crate::bindings::LNInvoice> for *mut wire_cst_ln_invoice {
9777 fn cst_decode(self) -> crate::bindings::LNInvoice {
9779 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9780 CstDecode::<crate::bindings::LNInvoice>::cst_decode(*wrap).into()
9781 }
9782 }
9783 impl CstDecode<crate::bindings::LNOffer> for *mut wire_cst_ln_offer {
9784 fn cst_decode(self) -> crate::bindings::LNOffer {
9786 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9787 CstDecode::<crate::bindings::LNOffer>::cst_decode(*wrap).into()
9788 }
9789 }
9790 impl CstDecode<crate::bindings::LnUrlAuthRequestData> for *mut wire_cst_ln_url_auth_request_data {
9791 fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
9793 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9794 CstDecode::<crate::bindings::LnUrlAuthRequestData>::cst_decode(*wrap).into()
9795 }
9796 }
9797 impl CstDecode<crate::bindings::LnUrlErrorData> for *mut wire_cst_ln_url_error_data {
9798 fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
9800 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9801 CstDecode::<crate::bindings::LnUrlErrorData>::cst_decode(*wrap).into()
9802 }
9803 }
9804 impl CstDecode<crate::model::LnUrlInfo> for *mut wire_cst_ln_url_info {
9805 fn cst_decode(self) -> crate::model::LnUrlInfo {
9807 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9808 CstDecode::<crate::model::LnUrlInfo>::cst_decode(*wrap).into()
9809 }
9810 }
9811 impl CstDecode<crate::bindings::LnUrlPayErrorData> for *mut wire_cst_ln_url_pay_error_data {
9812 fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
9814 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9815 CstDecode::<crate::bindings::LnUrlPayErrorData>::cst_decode(*wrap).into()
9816 }
9817 }
9818 impl CstDecode<crate::model::LnUrlPayRequest> for *mut wire_cst_ln_url_pay_request {
9819 fn cst_decode(self) -> crate::model::LnUrlPayRequest {
9821 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9822 CstDecode::<crate::model::LnUrlPayRequest>::cst_decode(*wrap).into()
9823 }
9824 }
9825 impl CstDecode<crate::bindings::LnUrlPayRequestData> for *mut wire_cst_ln_url_pay_request_data {
9826 fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
9828 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9829 CstDecode::<crate::bindings::LnUrlPayRequestData>::cst_decode(*wrap).into()
9830 }
9831 }
9832 impl CstDecode<crate::model::LnUrlPaySuccessData> for *mut wire_cst_ln_url_pay_success_data {
9833 fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
9835 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9836 CstDecode::<crate::model::LnUrlPaySuccessData>::cst_decode(*wrap).into()
9837 }
9838 }
9839 impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for *mut wire_cst_ln_url_withdraw_request {
9840 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
9842 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9843 CstDecode::<crate::bindings::LnUrlWithdrawRequest>::cst_decode(*wrap).into()
9844 }
9845 }
9846 impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
9847 for *mut wire_cst_ln_url_withdraw_request_data
9848 {
9849 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
9851 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9852 CstDecode::<crate::bindings::LnUrlWithdrawRequestData>::cst_decode(*wrap).into()
9853 }
9854 }
9855 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
9856 for *mut wire_cst_ln_url_withdraw_success_data
9857 {
9858 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
9860 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9861 CstDecode::<crate::bindings::duplicates::LnUrlWithdrawSuccessData>::cst_decode(*wrap)
9862 .into()
9863 }
9864 }
9865 impl CstDecode<crate::bindings::MessageSuccessActionData>
9866 for *mut wire_cst_message_success_action_data
9867 {
9868 fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
9870 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9871 CstDecode::<crate::bindings::MessageSuccessActionData>::cst_decode(*wrap).into()
9872 }
9873 }
9874 impl CstDecode<crate::model::PayAmount> for *mut wire_cst_pay_amount {
9875 fn cst_decode(self) -> crate::model::PayAmount {
9877 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9878 CstDecode::<crate::model::PayAmount>::cst_decode(*wrap).into()
9879 }
9880 }
9881 impl CstDecode<crate::model::PayOnchainRequest> for *mut wire_cst_pay_onchain_request {
9882 fn cst_decode(self) -> crate::model::PayOnchainRequest {
9884 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9885 CstDecode::<crate::model::PayOnchainRequest>::cst_decode(*wrap).into()
9886 }
9887 }
9888 impl CstDecode<crate::model::Payment> for *mut wire_cst_payment {
9889 fn cst_decode(self) -> crate::model::Payment {
9891 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9892 CstDecode::<crate::model::Payment>::cst_decode(*wrap).into()
9893 }
9894 }
9895 impl CstDecode<crate::model::PrepareBuyBitcoinRequest>
9896 for *mut wire_cst_prepare_buy_bitcoin_request
9897 {
9898 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
9900 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9901 CstDecode::<crate::model::PrepareBuyBitcoinRequest>::cst_decode(*wrap).into()
9902 }
9903 }
9904 impl CstDecode<crate::model::PrepareLnUrlPayRequest> for *mut wire_cst_prepare_ln_url_pay_request {
9905 fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
9907 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9908 CstDecode::<crate::model::PrepareLnUrlPayRequest>::cst_decode(*wrap).into()
9909 }
9910 }
9911 impl CstDecode<crate::model::PreparePayOnchainRequest>
9912 for *mut wire_cst_prepare_pay_onchain_request
9913 {
9914 fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
9916 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9917 CstDecode::<crate::model::PreparePayOnchainRequest>::cst_decode(*wrap).into()
9918 }
9919 }
9920 impl CstDecode<crate::model::PrepareReceiveRequest> for *mut wire_cst_prepare_receive_request {
9921 fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
9923 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9924 CstDecode::<crate::model::PrepareReceiveRequest>::cst_decode(*wrap).into()
9925 }
9926 }
9927 impl CstDecode<crate::model::PrepareRefundRequest> for *mut wire_cst_prepare_refund_request {
9928 fn cst_decode(self) -> crate::model::PrepareRefundRequest {
9930 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9931 CstDecode::<crate::model::PrepareRefundRequest>::cst_decode(*wrap).into()
9932 }
9933 }
9934 impl CstDecode<crate::model::PrepareSendRequest> for *mut wire_cst_prepare_send_request {
9935 fn cst_decode(self) -> crate::model::PrepareSendRequest {
9937 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9938 CstDecode::<crate::model::PrepareSendRequest>::cst_decode(*wrap).into()
9939 }
9940 }
9941 impl CstDecode<crate::model::ReceiveAmount> for *mut wire_cst_receive_amount {
9942 fn cst_decode(self) -> crate::model::ReceiveAmount {
9944 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9945 CstDecode::<crate::model::ReceiveAmount>::cst_decode(*wrap).into()
9946 }
9947 }
9948 impl CstDecode<crate::model::ReceivePaymentRequest> for *mut wire_cst_receive_payment_request {
9949 fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
9951 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9952 CstDecode::<crate::model::ReceivePaymentRequest>::cst_decode(*wrap).into()
9953 }
9954 }
9955 impl CstDecode<crate::model::RefundRequest> for *mut wire_cst_refund_request {
9956 fn cst_decode(self) -> crate::model::RefundRequest {
9958 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9959 CstDecode::<crate::model::RefundRequest>::cst_decode(*wrap).into()
9960 }
9961 }
9962 impl CstDecode<crate::model::RestoreRequest> for *mut wire_cst_restore_request {
9963 fn cst_decode(self) -> crate::model::RestoreRequest {
9965 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9966 CstDecode::<crate::model::RestoreRequest>::cst_decode(*wrap).into()
9967 }
9968 }
9969 impl CstDecode<crate::model::SdkEvent> for *mut wire_cst_sdk_event {
9970 fn cst_decode(self) -> crate::model::SdkEvent {
9972 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9973 CstDecode::<crate::model::SdkEvent>::cst_decode(*wrap).into()
9974 }
9975 }
9976 impl CstDecode<crate::model::SendPaymentRequest> for *mut wire_cst_send_payment_request {
9977 fn cst_decode(self) -> crate::model::SendPaymentRequest {
9979 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9980 CstDecode::<crate::model::SendPaymentRequest>::cst_decode(*wrap).into()
9981 }
9982 }
9983 impl CstDecode<crate::model::SignMessageRequest> for *mut wire_cst_sign_message_request {
9984 fn cst_decode(self) -> crate::model::SignMessageRequest {
9986 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9987 CstDecode::<crate::model::SignMessageRequest>::cst_decode(*wrap).into()
9988 }
9989 }
9990 impl CstDecode<crate::bindings::SuccessAction> for *mut wire_cst_success_action {
9991 fn cst_decode(self) -> crate::bindings::SuccessAction {
9993 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9994 CstDecode::<crate::bindings::SuccessAction>::cst_decode(*wrap).into()
9995 }
9996 }
9997 impl CstDecode<crate::bindings::SuccessActionProcessed> for *mut wire_cst_success_action_processed {
9998 fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
10000 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10001 CstDecode::<crate::bindings::SuccessActionProcessed>::cst_decode(*wrap).into()
10002 }
10003 }
10004 impl CstDecode<crate::bindings::Symbol> for *mut wire_cst_symbol {
10005 fn cst_decode(self) -> crate::bindings::Symbol {
10007 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10008 CstDecode::<crate::bindings::Symbol>::cst_decode(*wrap).into()
10009 }
10010 }
10011 impl CstDecode<u32> for *mut u32 {
10012 fn cst_decode(self) -> u32 {
10014 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10015 }
10016 }
10017 impl CstDecode<u64> for *mut u64 {
10018 fn cst_decode(self) -> u64 {
10020 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10021 }
10022 }
10023 impl CstDecode<crate::bindings::UrlSuccessActionData> for *mut wire_cst_url_success_action_data {
10024 fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
10026 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10027 CstDecode::<crate::bindings::UrlSuccessActionData>::cst_decode(*wrap).into()
10028 }
10029 }
10030 impl CstDecode<crate::model::BuyBitcoinRequest> for wire_cst_buy_bitcoin_request {
10031 fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
10033 crate::model::BuyBitcoinRequest {
10034 prepare_response: self.prepare_response.cst_decode(),
10035 redirect_url: self.redirect_url.cst_decode(),
10036 }
10037 }
10038 }
10039 impl CstDecode<crate::model::CheckMessageRequest> for wire_cst_check_message_request {
10040 fn cst_decode(self) -> crate::model::CheckMessageRequest {
10042 crate::model::CheckMessageRequest {
10043 message: self.message.cst_decode(),
10044 pubkey: self.pubkey.cst_decode(),
10045 signature: self.signature.cst_decode(),
10046 }
10047 }
10048 }
10049 impl CstDecode<crate::model::CheckMessageResponse> for wire_cst_check_message_response {
10050 fn cst_decode(self) -> crate::model::CheckMessageResponse {
10052 crate::model::CheckMessageResponse {
10053 is_valid: self.is_valid.cst_decode(),
10054 }
10055 }
10056 }
10057 impl CstDecode<crate::model::Config> for wire_cst_config {
10058 fn cst_decode(self) -> crate::model::Config {
10060 crate::model::Config {
10061 liquid_explorer: self.liquid_explorer.cst_decode(),
10062 bitcoin_explorer: self.bitcoin_explorer.cst_decode(),
10063 working_dir: self.working_dir.cst_decode(),
10064 cache_dir: self.cache_dir.cst_decode(),
10065 network: self.network.cst_decode(),
10066 payment_timeout_sec: self.payment_timeout_sec.cst_decode(),
10067 sync_service_url: self.sync_service_url.cst_decode(),
10068 zero_conf_max_amount_sat: self.zero_conf_max_amount_sat.cst_decode(),
10069 breez_api_key: self.breez_api_key.cst_decode(),
10070 external_input_parsers: self.external_input_parsers.cst_decode(),
10071 use_default_external_input_parsers: self
10072 .use_default_external_input_parsers
10073 .cst_decode(),
10074 onchain_fee_rate_leeway_sat_per_vbyte: self
10075 .onchain_fee_rate_leeway_sat_per_vbyte
10076 .cst_decode(),
10077 asset_metadata: self.asset_metadata.cst_decode(),
10078 sideswap_api_key: self.sideswap_api_key.cst_decode(),
10079 }
10080 }
10081 }
10082 impl CstDecode<crate::model::ConnectRequest> for wire_cst_connect_request {
10083 fn cst_decode(self) -> crate::model::ConnectRequest {
10085 crate::model::ConnectRequest {
10086 config: self.config.cst_decode(),
10087 mnemonic: self.mnemonic.cst_decode(),
10088 passphrase: self.passphrase.cst_decode(),
10089 seed: self.seed.cst_decode(),
10090 }
10091 }
10092 }
10093 impl CstDecode<crate::bindings::CurrencyInfo> for wire_cst_currency_info {
10094 fn cst_decode(self) -> crate::bindings::CurrencyInfo {
10096 crate::bindings::CurrencyInfo {
10097 name: self.name.cst_decode(),
10098 fraction_size: self.fraction_size.cst_decode(),
10099 spacing: self.spacing.cst_decode(),
10100 symbol: self.symbol.cst_decode(),
10101 uniq_symbol: self.uniq_symbol.cst_decode(),
10102 localized_name: self.localized_name.cst_decode(),
10103 locale_overrides: self.locale_overrides.cst_decode(),
10104 }
10105 }
10106 }
10107 impl CstDecode<crate::bindings::ExternalInputParser> for wire_cst_external_input_parser {
10108 fn cst_decode(self) -> crate::bindings::ExternalInputParser {
10110 crate::bindings::ExternalInputParser {
10111 provider_id: self.provider_id.cst_decode(),
10112 input_regex: self.input_regex.cst_decode(),
10113 parser_url: self.parser_url.cst_decode(),
10114 }
10115 }
10116 }
10117 impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
10118 for wire_cst_fetch_payment_proposed_fees_request
10119 {
10120 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
10122 crate::model::FetchPaymentProposedFeesRequest {
10123 swap_id: self.swap_id.cst_decode(),
10124 }
10125 }
10126 }
10127 impl CstDecode<crate::model::FetchPaymentProposedFeesResponse>
10128 for wire_cst_fetch_payment_proposed_fees_response
10129 {
10130 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesResponse {
10132 crate::model::FetchPaymentProposedFeesResponse {
10133 swap_id: self.swap_id.cst_decode(),
10134 fees_sat: self.fees_sat.cst_decode(),
10135 payer_amount_sat: self.payer_amount_sat.cst_decode(),
10136 receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
10137 }
10138 }
10139 }
10140 impl CstDecode<crate::bindings::FiatCurrency> for wire_cst_fiat_currency {
10141 fn cst_decode(self) -> crate::bindings::FiatCurrency {
10143 crate::bindings::FiatCurrency {
10144 id: self.id.cst_decode(),
10145 info: self.info.cst_decode(),
10146 }
10147 }
10148 }
10149 impl CstDecode<crate::model::GetInfoResponse> for wire_cst_get_info_response {
10150 fn cst_decode(self) -> crate::model::GetInfoResponse {
10152 crate::model::GetInfoResponse {
10153 wallet_info: self.wallet_info.cst_decode(),
10154 blockchain_info: self.blockchain_info.cst_decode(),
10155 }
10156 }
10157 }
10158 impl CstDecode<crate::model::GetPaymentRequest> for wire_cst_get_payment_request {
10159 fn cst_decode(self) -> crate::model::GetPaymentRequest {
10161 match self.tag {
10162 0 => {
10163 let ans = unsafe { self.kind.PaymentHash };
10164 crate::model::GetPaymentRequest::PaymentHash {
10165 payment_hash: ans.payment_hash.cst_decode(),
10166 }
10167 }
10168 1 => {
10169 let ans = unsafe { self.kind.SwapId };
10170 crate::model::GetPaymentRequest::SwapId {
10171 swap_id: ans.swap_id.cst_decode(),
10172 }
10173 }
10174 _ => unreachable!(),
10175 }
10176 }
10177 }
10178 impl CstDecode<crate::bindings::InputType> for wire_cst_input_type {
10179 fn cst_decode(self) -> crate::bindings::InputType {
10181 match self.tag {
10182 0 => {
10183 let ans = unsafe { self.kind.BitcoinAddress };
10184 crate::bindings::InputType::BitcoinAddress {
10185 address: ans.address.cst_decode(),
10186 }
10187 }
10188 1 => {
10189 let ans = unsafe { self.kind.LiquidAddress };
10190 crate::bindings::InputType::LiquidAddress {
10191 address: ans.address.cst_decode(),
10192 }
10193 }
10194 2 => {
10195 let ans = unsafe { self.kind.Bolt11 };
10196 crate::bindings::InputType::Bolt11 {
10197 invoice: ans.invoice.cst_decode(),
10198 }
10199 }
10200 3 => {
10201 let ans = unsafe { self.kind.Bolt12Offer };
10202 crate::bindings::InputType::Bolt12Offer {
10203 offer: ans.offer.cst_decode(),
10204 bip353_address: ans.bip353_address.cst_decode(),
10205 }
10206 }
10207 4 => {
10208 let ans = unsafe { self.kind.NodeId };
10209 crate::bindings::InputType::NodeId {
10210 node_id: ans.node_id.cst_decode(),
10211 }
10212 }
10213 5 => {
10214 let ans = unsafe { self.kind.Url };
10215 crate::bindings::InputType::Url {
10216 url: ans.url.cst_decode(),
10217 }
10218 }
10219 6 => {
10220 let ans = unsafe { self.kind.LnUrlPay };
10221 crate::bindings::InputType::LnUrlPay {
10222 data: ans.data.cst_decode(),
10223 bip353_address: ans.bip353_address.cst_decode(),
10224 }
10225 }
10226 7 => {
10227 let ans = unsafe { self.kind.LnUrlWithdraw };
10228 crate::bindings::InputType::LnUrlWithdraw {
10229 data: ans.data.cst_decode(),
10230 }
10231 }
10232 8 => {
10233 let ans = unsafe { self.kind.LnUrlAuth };
10234 crate::bindings::InputType::LnUrlAuth {
10235 data: ans.data.cst_decode(),
10236 }
10237 }
10238 9 => {
10239 let ans = unsafe { self.kind.LnUrlError };
10240 crate::bindings::InputType::LnUrlError {
10241 data: ans.data.cst_decode(),
10242 }
10243 }
10244 _ => unreachable!(),
10245 }
10246 }
10247 }
10248 impl CstDecode<crate::model::LightningPaymentLimitsResponse>
10249 for wire_cst_lightning_payment_limits_response
10250 {
10251 fn cst_decode(self) -> crate::model::LightningPaymentLimitsResponse {
10253 crate::model::LightningPaymentLimitsResponse {
10254 send: self.send.cst_decode(),
10255 receive: self.receive.cst_decode(),
10256 }
10257 }
10258 }
10259 impl CstDecode<crate::model::Limits> for wire_cst_limits {
10260 fn cst_decode(self) -> crate::model::Limits {
10262 crate::model::Limits {
10263 min_sat: self.min_sat.cst_decode(),
10264 max_sat: self.max_sat.cst_decode(),
10265 max_zero_conf_sat: self.max_zero_conf_sat.cst_decode(),
10266 }
10267 }
10268 }
10269 impl CstDecode<crate::bindings::LiquidAddressData> for wire_cst_liquid_address_data {
10270 fn cst_decode(self) -> crate::bindings::LiquidAddressData {
10272 crate::bindings::LiquidAddressData {
10273 address: self.address.cst_decode(),
10274 network: self.network.cst_decode(),
10275 asset_id: self.asset_id.cst_decode(),
10276 amount: self.amount.cst_decode(),
10277 amount_sat: self.amount_sat.cst_decode(),
10278 label: self.label.cst_decode(),
10279 message: self.message.cst_decode(),
10280 }
10281 }
10282 }
10283 impl CstDecode<Vec<String>> for *mut wire_cst_list_String {
10284 fn cst_decode(self) -> Vec<String> {
10286 let vec = unsafe {
10287 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10288 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10289 };
10290 vec.into_iter().map(CstDecode::cst_decode).collect()
10291 }
10292 }
10293 impl CstDecode<Vec<crate::model::AssetBalance>> for *mut wire_cst_list_asset_balance {
10294 fn cst_decode(self) -> Vec<crate::model::AssetBalance> {
10296 let vec = unsafe {
10297 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10298 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10299 };
10300 vec.into_iter().map(CstDecode::cst_decode).collect()
10301 }
10302 }
10303 impl CstDecode<Vec<crate::model::AssetMetadata>> for *mut wire_cst_list_asset_metadata {
10304 fn cst_decode(self) -> Vec<crate::model::AssetMetadata> {
10306 let vec = unsafe {
10307 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10308 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10309 };
10310 vec.into_iter().map(CstDecode::cst_decode).collect()
10311 }
10312 }
10313 impl CstDecode<Vec<crate::bindings::ExternalInputParser>>
10314 for *mut wire_cst_list_external_input_parser
10315 {
10316 fn cst_decode(self) -> Vec<crate::bindings::ExternalInputParser> {
10318 let vec = unsafe {
10319 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10320 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10321 };
10322 vec.into_iter().map(CstDecode::cst_decode).collect()
10323 }
10324 }
10325 impl CstDecode<Vec<crate::bindings::FiatCurrency>> for *mut wire_cst_list_fiat_currency {
10326 fn cst_decode(self) -> Vec<crate::bindings::FiatCurrency> {
10328 let vec = unsafe {
10329 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10330 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10331 };
10332 vec.into_iter().map(CstDecode::cst_decode).collect()
10333 }
10334 }
10335 impl CstDecode<Vec<crate::bindings::LnOfferBlindedPath>>
10336 for *mut wire_cst_list_ln_offer_blinded_path
10337 {
10338 fn cst_decode(self) -> Vec<crate::bindings::LnOfferBlindedPath> {
10340 let vec = unsafe {
10341 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10342 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10343 };
10344 vec.into_iter().map(CstDecode::cst_decode).collect()
10345 }
10346 }
10347 impl CstDecode<Vec<crate::bindings::LocaleOverrides>> for *mut wire_cst_list_locale_overrides {
10348 fn cst_decode(self) -> Vec<crate::bindings::LocaleOverrides> {
10350 let vec = unsafe {
10351 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10352 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10353 };
10354 vec.into_iter().map(CstDecode::cst_decode).collect()
10355 }
10356 }
10357 impl CstDecode<Vec<crate::bindings::LocalizedName>> for *mut wire_cst_list_localized_name {
10358 fn cst_decode(self) -> Vec<crate::bindings::LocalizedName> {
10360 let vec = unsafe {
10361 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10362 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10363 };
10364 vec.into_iter().map(CstDecode::cst_decode).collect()
10365 }
10366 }
10367 impl CstDecode<Vec<crate::model::Payment>> for *mut wire_cst_list_payment {
10368 fn cst_decode(self) -> Vec<crate::model::Payment> {
10370 let vec = unsafe {
10371 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10372 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10373 };
10374 vec.into_iter().map(CstDecode::cst_decode).collect()
10375 }
10376 }
10377 impl CstDecode<crate::model::ListPaymentDetails> for wire_cst_list_payment_details {
10378 fn cst_decode(self) -> crate::model::ListPaymentDetails {
10380 match self.tag {
10381 0 => {
10382 let ans = unsafe { self.kind.Liquid };
10383 crate::model::ListPaymentDetails::Liquid {
10384 asset_id: ans.asset_id.cst_decode(),
10385 destination: ans.destination.cst_decode(),
10386 }
10387 }
10388 1 => {
10389 let ans = unsafe { self.kind.Bitcoin };
10390 crate::model::ListPaymentDetails::Bitcoin {
10391 address: ans.address.cst_decode(),
10392 }
10393 }
10394 _ => unreachable!(),
10395 }
10396 }
10397 }
10398 impl CstDecode<Vec<crate::model::PaymentState>> for *mut wire_cst_list_payment_state {
10399 fn cst_decode(self) -> Vec<crate::model::PaymentState> {
10401 let vec = unsafe {
10402 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10403 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10404 };
10405 vec.into_iter().map(CstDecode::cst_decode).collect()
10406 }
10407 }
10408 impl CstDecode<Vec<crate::model::PaymentType>> for *mut wire_cst_list_payment_type {
10409 fn cst_decode(self) -> Vec<crate::model::PaymentType> {
10411 let vec = unsafe {
10412 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10413 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10414 };
10415 vec.into_iter().map(CstDecode::cst_decode).collect()
10416 }
10417 }
10418 impl CstDecode<crate::model::ListPaymentsRequest> for wire_cst_list_payments_request {
10419 fn cst_decode(self) -> crate::model::ListPaymentsRequest {
10421 crate::model::ListPaymentsRequest {
10422 filters: self.filters.cst_decode(),
10423 states: self.states.cst_decode(),
10424 from_timestamp: self.from_timestamp.cst_decode(),
10425 to_timestamp: self.to_timestamp.cst_decode(),
10426 offset: self.offset.cst_decode(),
10427 limit: self.limit.cst_decode(),
10428 details: self.details.cst_decode(),
10429 sort_ascending: self.sort_ascending.cst_decode(),
10430 }
10431 }
10432 }
10433 impl CstDecode<Vec<u8>> for *mut wire_cst_list_prim_u_8_strict {
10434 fn cst_decode(self) -> Vec<u8> {
10436 unsafe {
10437 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10438 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10439 }
10440 }
10441 }
10442 impl CstDecode<Vec<crate::bindings::Rate>> for *mut wire_cst_list_rate {
10443 fn cst_decode(self) -> Vec<crate::bindings::Rate> {
10445 let vec = unsafe {
10446 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10447 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10448 };
10449 vec.into_iter().map(CstDecode::cst_decode).collect()
10450 }
10451 }
10452 impl CstDecode<Vec<crate::model::RefundableSwap>> for *mut wire_cst_list_refundable_swap {
10453 fn cst_decode(self) -> Vec<crate::model::RefundableSwap> {
10455 let vec = unsafe {
10456 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10457 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10458 };
10459 vec.into_iter().map(CstDecode::cst_decode).collect()
10460 }
10461 }
10462 impl CstDecode<Vec<crate::bindings::RouteHint>> for *mut wire_cst_list_route_hint {
10463 fn cst_decode(self) -> Vec<crate::bindings::RouteHint> {
10465 let vec = unsafe {
10466 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10467 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10468 };
10469 vec.into_iter().map(CstDecode::cst_decode).collect()
10470 }
10471 }
10472 impl CstDecode<Vec<crate::bindings::RouteHintHop>> for *mut wire_cst_list_route_hint_hop {
10473 fn cst_decode(self) -> Vec<crate::bindings::RouteHintHop> {
10475 let vec = unsafe {
10476 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10477 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10478 };
10479 vec.into_iter().map(CstDecode::cst_decode).collect()
10480 }
10481 }
10482 impl CstDecode<crate::bindings::LNInvoice> for wire_cst_ln_invoice {
10483 fn cst_decode(self) -> crate::bindings::LNInvoice {
10485 crate::bindings::LNInvoice {
10486 bolt11: self.bolt11.cst_decode(),
10487 network: self.network.cst_decode(),
10488 payee_pubkey: self.payee_pubkey.cst_decode(),
10489 payment_hash: self.payment_hash.cst_decode(),
10490 description: self.description.cst_decode(),
10491 description_hash: self.description_hash.cst_decode(),
10492 amount_msat: self.amount_msat.cst_decode(),
10493 timestamp: self.timestamp.cst_decode(),
10494 expiry: self.expiry.cst_decode(),
10495 routing_hints: self.routing_hints.cst_decode(),
10496 payment_secret: self.payment_secret.cst_decode(),
10497 min_final_cltv_expiry_delta: self.min_final_cltv_expiry_delta.cst_decode(),
10498 }
10499 }
10500 }
10501 impl CstDecode<crate::bindings::LNOffer> for wire_cst_ln_offer {
10502 fn cst_decode(self) -> crate::bindings::LNOffer {
10504 crate::bindings::LNOffer {
10505 offer: self.offer.cst_decode(),
10506 chains: self.chains.cst_decode(),
10507 min_amount: self.min_amount.cst_decode(),
10508 description: self.description.cst_decode(),
10509 absolute_expiry: self.absolute_expiry.cst_decode(),
10510 issuer: self.issuer.cst_decode(),
10511 signing_pubkey: self.signing_pubkey.cst_decode(),
10512 paths: self.paths.cst_decode(),
10513 }
10514 }
10515 }
10516 impl CstDecode<crate::bindings::LnOfferBlindedPath> for wire_cst_ln_offer_blinded_path {
10517 fn cst_decode(self) -> crate::bindings::LnOfferBlindedPath {
10519 crate::bindings::LnOfferBlindedPath {
10520 blinded_hops: self.blinded_hops.cst_decode(),
10521 }
10522 }
10523 }
10524 impl CstDecode<crate::bindings::duplicates::LnUrlAuthError> for wire_cst_ln_url_auth_error {
10525 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlAuthError {
10527 match self.tag {
10528 0 => {
10529 let ans = unsafe { self.kind.Generic };
10530 crate::bindings::duplicates::LnUrlAuthError::Generic {
10531 err: ans.err.cst_decode(),
10532 }
10533 }
10534 1 => {
10535 let ans = unsafe { self.kind.InvalidUri };
10536 crate::bindings::duplicates::LnUrlAuthError::InvalidUri {
10537 err: ans.err.cst_decode(),
10538 }
10539 }
10540 2 => {
10541 let ans = unsafe { self.kind.ServiceConnectivity };
10542 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
10543 err: ans.err.cst_decode(),
10544 }
10545 }
10546 _ => unreachable!(),
10547 }
10548 }
10549 }
10550 impl CstDecode<crate::bindings::LnUrlAuthRequestData> for wire_cst_ln_url_auth_request_data {
10551 fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10553 crate::bindings::LnUrlAuthRequestData {
10554 k1: self.k1.cst_decode(),
10555 action: self.action.cst_decode(),
10556 domain: self.domain.cst_decode(),
10557 url: self.url.cst_decode(),
10558 }
10559 }
10560 }
10561 impl CstDecode<crate::bindings::duplicates::LnUrlCallbackStatus>
10562 for wire_cst_ln_url_callback_status
10563 {
10564 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
10566 match self.tag {
10567 0 => crate::bindings::duplicates::LnUrlCallbackStatus::Ok,
10568 1 => {
10569 let ans = unsafe { self.kind.ErrorStatus };
10570 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
10571 data: ans.data.cst_decode(),
10572 }
10573 }
10574 _ => unreachable!(),
10575 }
10576 }
10577 }
10578 impl CstDecode<crate::bindings::LnUrlErrorData> for wire_cst_ln_url_error_data {
10579 fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10581 crate::bindings::LnUrlErrorData {
10582 reason: self.reason.cst_decode(),
10583 }
10584 }
10585 }
10586 impl CstDecode<crate::model::LnUrlInfo> for wire_cst_ln_url_info {
10587 fn cst_decode(self) -> crate::model::LnUrlInfo {
10589 crate::model::LnUrlInfo {
10590 ln_address: self.ln_address.cst_decode(),
10591 lnurl_pay_comment: self.lnurl_pay_comment.cst_decode(),
10592 lnurl_pay_domain: self.lnurl_pay_domain.cst_decode(),
10593 lnurl_pay_metadata: self.lnurl_pay_metadata.cst_decode(),
10594 lnurl_pay_success_action: self.lnurl_pay_success_action.cst_decode(),
10595 lnurl_pay_unprocessed_success_action: self
10596 .lnurl_pay_unprocessed_success_action
10597 .cst_decode(),
10598 lnurl_withdraw_endpoint: self.lnurl_withdraw_endpoint.cst_decode(),
10599 }
10600 }
10601 }
10602 impl CstDecode<crate::bindings::duplicates::LnUrlPayError> for wire_cst_ln_url_pay_error {
10603 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlPayError {
10605 match self.tag {
10606 0 => crate::bindings::duplicates::LnUrlPayError::AlreadyPaid,
10607 1 => {
10608 let ans = unsafe { self.kind.Generic };
10609 crate::bindings::duplicates::LnUrlPayError::Generic {
10610 err: ans.err.cst_decode(),
10611 }
10612 }
10613 2 => {
10614 let ans = unsafe { self.kind.InvalidAmount };
10615 crate::bindings::duplicates::LnUrlPayError::InvalidAmount {
10616 err: ans.err.cst_decode(),
10617 }
10618 }
10619 3 => {
10620 let ans = unsafe { self.kind.InvalidInvoice };
10621 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice {
10622 err: ans.err.cst_decode(),
10623 }
10624 }
10625 4 => {
10626 let ans = unsafe { self.kind.InvalidNetwork };
10627 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork {
10628 err: ans.err.cst_decode(),
10629 }
10630 }
10631 5 => {
10632 let ans = unsafe { self.kind.InvalidUri };
10633 crate::bindings::duplicates::LnUrlPayError::InvalidUri {
10634 err: ans.err.cst_decode(),
10635 }
10636 }
10637 6 => {
10638 let ans = unsafe { self.kind.InvoiceExpired };
10639 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired {
10640 err: ans.err.cst_decode(),
10641 }
10642 }
10643 7 => {
10644 let ans = unsafe { self.kind.PaymentFailed };
10645 crate::bindings::duplicates::LnUrlPayError::PaymentFailed {
10646 err: ans.err.cst_decode(),
10647 }
10648 }
10649 8 => {
10650 let ans = unsafe { self.kind.PaymentTimeout };
10651 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout {
10652 err: ans.err.cst_decode(),
10653 }
10654 }
10655 9 => {
10656 let ans = unsafe { self.kind.RouteNotFound };
10657 crate::bindings::duplicates::LnUrlPayError::RouteNotFound {
10658 err: ans.err.cst_decode(),
10659 }
10660 }
10661 10 => {
10662 let ans = unsafe { self.kind.RouteTooExpensive };
10663 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
10664 err: ans.err.cst_decode(),
10665 }
10666 }
10667 11 => {
10668 let ans = unsafe { self.kind.ServiceConnectivity };
10669 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
10670 err: ans.err.cst_decode(),
10671 }
10672 }
10673 _ => unreachable!(),
10674 }
10675 }
10676 }
10677 impl CstDecode<crate::bindings::LnUrlPayErrorData> for wire_cst_ln_url_pay_error_data {
10678 fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10680 crate::bindings::LnUrlPayErrorData {
10681 payment_hash: self.payment_hash.cst_decode(),
10682 reason: self.reason.cst_decode(),
10683 }
10684 }
10685 }
10686 impl CstDecode<crate::model::LnUrlPayRequest> for wire_cst_ln_url_pay_request {
10687 fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10689 crate::model::LnUrlPayRequest {
10690 prepare_response: self.prepare_response.cst_decode(),
10691 }
10692 }
10693 }
10694 impl CstDecode<crate::bindings::LnUrlPayRequestData> for wire_cst_ln_url_pay_request_data {
10695 fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10697 crate::bindings::LnUrlPayRequestData {
10698 callback: self.callback.cst_decode(),
10699 min_sendable: self.min_sendable.cst_decode(),
10700 max_sendable: self.max_sendable.cst_decode(),
10701 metadata_str: self.metadata_str.cst_decode(),
10702 comment_allowed: self.comment_allowed.cst_decode(),
10703 domain: self.domain.cst_decode(),
10704 allows_nostr: self.allows_nostr.cst_decode(),
10705 nostr_pubkey: self.nostr_pubkey.cst_decode(),
10706 ln_address: self.ln_address.cst_decode(),
10707 }
10708 }
10709 }
10710 impl CstDecode<crate::model::LnUrlPayResult> for wire_cst_ln_url_pay_result {
10711 fn cst_decode(self) -> crate::model::LnUrlPayResult {
10713 match self.tag {
10714 0 => {
10715 let ans = unsafe { self.kind.EndpointSuccess };
10716 crate::model::LnUrlPayResult::EndpointSuccess {
10717 data: ans.data.cst_decode(),
10718 }
10719 }
10720 1 => {
10721 let ans = unsafe { self.kind.EndpointError };
10722 crate::model::LnUrlPayResult::EndpointError {
10723 data: ans.data.cst_decode(),
10724 }
10725 }
10726 2 => {
10727 let ans = unsafe { self.kind.PayError };
10728 crate::model::LnUrlPayResult::PayError {
10729 data: ans.data.cst_decode(),
10730 }
10731 }
10732 _ => unreachable!(),
10733 }
10734 }
10735 }
10736 impl CstDecode<crate::model::LnUrlPaySuccessData> for wire_cst_ln_url_pay_success_data {
10737 fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10739 crate::model::LnUrlPaySuccessData {
10740 payment: self.payment.cst_decode(),
10741 success_action: self.success_action.cst_decode(),
10742 }
10743 }
10744 }
10745 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawError> for wire_cst_ln_url_withdraw_error {
10746 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
10748 match self.tag {
10749 0 => {
10750 let ans = unsafe { self.kind.Generic };
10751 crate::bindings::duplicates::LnUrlWithdrawError::Generic {
10752 err: ans.err.cst_decode(),
10753 }
10754 }
10755 1 => {
10756 let ans = unsafe { self.kind.InvalidAmount };
10757 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
10758 err: ans.err.cst_decode(),
10759 }
10760 }
10761 2 => {
10762 let ans = unsafe { self.kind.InvalidInvoice };
10763 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
10764 err: ans.err.cst_decode(),
10765 }
10766 }
10767 3 => {
10768 let ans = unsafe { self.kind.InvalidUri };
10769 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
10770 err: ans.err.cst_decode(),
10771 }
10772 }
10773 4 => {
10774 let ans = unsafe { self.kind.InvoiceNoRoutingHints };
10775 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
10776 err: ans.err.cst_decode(),
10777 }
10778 }
10779 5 => {
10780 let ans = unsafe { self.kind.ServiceConnectivity };
10781 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
10782 err: ans.err.cst_decode(),
10783 }
10784 }
10785 _ => unreachable!(),
10786 }
10787 }
10788 }
10789 impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for wire_cst_ln_url_withdraw_request {
10790 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
10792 crate::bindings::LnUrlWithdrawRequest {
10793 data: self.data.cst_decode(),
10794 amount_msat: self.amount_msat.cst_decode(),
10795 description: self.description.cst_decode(),
10796 }
10797 }
10798 }
10799 impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
10800 for wire_cst_ln_url_withdraw_request_data
10801 {
10802 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
10804 crate::bindings::LnUrlWithdrawRequestData {
10805 callback: self.callback.cst_decode(),
10806 k1: self.k1.cst_decode(),
10807 default_description: self.default_description.cst_decode(),
10808 min_withdrawable: self.min_withdrawable.cst_decode(),
10809 max_withdrawable: self.max_withdrawable.cst_decode(),
10810 }
10811 }
10812 }
10813 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawResult>
10814 for wire_cst_ln_url_withdraw_result
10815 {
10816 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
10818 match self.tag {
10819 0 => {
10820 let ans = unsafe { self.kind.Ok };
10821 crate::bindings::duplicates::LnUrlWithdrawResult::Ok {
10822 data: ans.data.cst_decode(),
10823 }
10824 }
10825 1 => {
10826 let ans = unsafe { self.kind.Timeout };
10827 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
10828 data: ans.data.cst_decode(),
10829 }
10830 }
10831 2 => {
10832 let ans = unsafe { self.kind.ErrorStatus };
10833 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
10834 data: ans.data.cst_decode(),
10835 }
10836 }
10837 _ => unreachable!(),
10838 }
10839 }
10840 }
10841 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
10842 for wire_cst_ln_url_withdraw_success_data
10843 {
10844 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
10846 crate::bindings::duplicates::LnUrlWithdrawSuccessData {
10847 invoice: self.invoice.cst_decode(),
10848 }
10849 }
10850 }
10851 impl CstDecode<crate::bindings::LocaleOverrides> for wire_cst_locale_overrides {
10852 fn cst_decode(self) -> crate::bindings::LocaleOverrides {
10854 crate::bindings::LocaleOverrides {
10855 locale: self.locale.cst_decode(),
10856 spacing: self.spacing.cst_decode(),
10857 symbol: self.symbol.cst_decode(),
10858 }
10859 }
10860 }
10861 impl CstDecode<crate::bindings::LocalizedName> for wire_cst_localized_name {
10862 fn cst_decode(self) -> crate::bindings::LocalizedName {
10864 crate::bindings::LocalizedName {
10865 locale: self.locale.cst_decode(),
10866 name: self.name.cst_decode(),
10867 }
10868 }
10869 }
10870 impl CstDecode<crate::model::LogEntry> for wire_cst_log_entry {
10871 fn cst_decode(self) -> crate::model::LogEntry {
10873 crate::model::LogEntry {
10874 line: self.line.cst_decode(),
10875 level: self.level.cst_decode(),
10876 }
10877 }
10878 }
10879 impl CstDecode<crate::bindings::MessageSuccessActionData> for wire_cst_message_success_action_data {
10880 fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
10882 crate::bindings::MessageSuccessActionData {
10883 message: self.message.cst_decode(),
10884 }
10885 }
10886 }
10887 impl CstDecode<crate::model::OnchainPaymentLimitsResponse>
10888 for wire_cst_onchain_payment_limits_response
10889 {
10890 fn cst_decode(self) -> crate::model::OnchainPaymentLimitsResponse {
10892 crate::model::OnchainPaymentLimitsResponse {
10893 send: self.send.cst_decode(),
10894 receive: self.receive.cst_decode(),
10895 }
10896 }
10897 }
10898 impl CstDecode<crate::model::PayAmount> for wire_cst_pay_amount {
10899 fn cst_decode(self) -> crate::model::PayAmount {
10901 match self.tag {
10902 0 => {
10903 let ans = unsafe { self.kind.Bitcoin };
10904 crate::model::PayAmount::Bitcoin {
10905 receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
10906 }
10907 }
10908 1 => {
10909 let ans = unsafe { self.kind.Asset };
10910 crate::model::PayAmount::Asset {
10911 asset_id: ans.asset_id.cst_decode(),
10912 receiver_amount: ans.receiver_amount.cst_decode(),
10913 estimate_asset_fees: ans.estimate_asset_fees.cst_decode(),
10914 }
10915 }
10916 2 => crate::model::PayAmount::Drain,
10917 _ => unreachable!(),
10918 }
10919 }
10920 }
10921 impl CstDecode<crate::model::PayOnchainRequest> for wire_cst_pay_onchain_request {
10922 fn cst_decode(self) -> crate::model::PayOnchainRequest {
10924 crate::model::PayOnchainRequest {
10925 address: self.address.cst_decode(),
10926 prepare_response: self.prepare_response.cst_decode(),
10927 }
10928 }
10929 }
10930 impl CstDecode<crate::model::Payment> for wire_cst_payment {
10931 fn cst_decode(self) -> crate::model::Payment {
10933 crate::model::Payment {
10934 destination: self.destination.cst_decode(),
10935 tx_id: self.tx_id.cst_decode(),
10936 unblinding_data: self.unblinding_data.cst_decode(),
10937 timestamp: self.timestamp.cst_decode(),
10938 amount_sat: self.amount_sat.cst_decode(),
10939 fees_sat: self.fees_sat.cst_decode(),
10940 swapper_fees_sat: self.swapper_fees_sat.cst_decode(),
10941 payment_type: self.payment_type.cst_decode(),
10942 status: self.status.cst_decode(),
10943 details: self.details.cst_decode(),
10944 }
10945 }
10946 }
10947 impl CstDecode<crate::model::PaymentDetails> for wire_cst_payment_details {
10948 fn cst_decode(self) -> crate::model::PaymentDetails {
10950 match self.tag {
10951 0 => {
10952 let ans = unsafe { self.kind.Lightning };
10953 crate::model::PaymentDetails::Lightning {
10954 swap_id: ans.swap_id.cst_decode(),
10955 description: ans.description.cst_decode(),
10956 liquid_expiration_blockheight: ans
10957 .liquid_expiration_blockheight
10958 .cst_decode(),
10959 preimage: ans.preimage.cst_decode(),
10960 invoice: ans.invoice.cst_decode(),
10961 bolt12_offer: ans.bolt12_offer.cst_decode(),
10962 payment_hash: ans.payment_hash.cst_decode(),
10963 destination_pubkey: ans.destination_pubkey.cst_decode(),
10964 lnurl_info: ans.lnurl_info.cst_decode(),
10965 bip353_address: ans.bip353_address.cst_decode(),
10966 claim_tx_id: ans.claim_tx_id.cst_decode(),
10967 refund_tx_id: ans.refund_tx_id.cst_decode(),
10968 refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
10969 }
10970 }
10971 1 => {
10972 let ans = unsafe { self.kind.Liquid };
10973 crate::model::PaymentDetails::Liquid {
10974 destination: ans.destination.cst_decode(),
10975 description: ans.description.cst_decode(),
10976 asset_id: ans.asset_id.cst_decode(),
10977 asset_info: ans.asset_info.cst_decode(),
10978 lnurl_info: ans.lnurl_info.cst_decode(),
10979 bip353_address: ans.bip353_address.cst_decode(),
10980 }
10981 }
10982 2 => {
10983 let ans = unsafe { self.kind.Bitcoin };
10984 crate::model::PaymentDetails::Bitcoin {
10985 swap_id: ans.swap_id.cst_decode(),
10986 description: ans.description.cst_decode(),
10987 auto_accepted_fees: ans.auto_accepted_fees.cst_decode(),
10988 liquid_expiration_blockheight: ans
10989 .liquid_expiration_blockheight
10990 .cst_decode(),
10991 bitcoin_expiration_blockheight: ans
10992 .bitcoin_expiration_blockheight
10993 .cst_decode(),
10994 claim_tx_id: ans.claim_tx_id.cst_decode(),
10995 refund_tx_id: ans.refund_tx_id.cst_decode(),
10996 refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
10997 }
10998 }
10999 _ => unreachable!(),
11000 }
11001 }
11002 }
11003 impl CstDecode<crate::error::PaymentError> for wire_cst_payment_error {
11004 fn cst_decode(self) -> crate::error::PaymentError {
11006 match self.tag {
11007 0 => crate::error::PaymentError::AlreadyClaimed,
11008 1 => crate::error::PaymentError::AlreadyPaid,
11009 2 => crate::error::PaymentError::PaymentInProgress,
11010 3 => crate::error::PaymentError::AmountOutOfRange,
11011 4 => {
11012 let ans = unsafe { self.kind.AmountMissing };
11013 crate::error::PaymentError::AmountMissing {
11014 err: ans.err.cst_decode(),
11015 }
11016 }
11017 5 => {
11018 let ans = unsafe { self.kind.AssetError };
11019 crate::error::PaymentError::AssetError {
11020 err: ans.err.cst_decode(),
11021 }
11022 }
11023 6 => {
11024 let ans = unsafe { self.kind.InvalidNetwork };
11025 crate::error::PaymentError::InvalidNetwork {
11026 err: ans.err.cst_decode(),
11027 }
11028 }
11029 7 => {
11030 let ans = unsafe { self.kind.Generic };
11031 crate::error::PaymentError::Generic {
11032 err: ans.err.cst_decode(),
11033 }
11034 }
11035 8 => crate::error::PaymentError::InvalidOrExpiredFees,
11036 9 => crate::error::PaymentError::InsufficientFunds,
11037 10 => {
11038 let ans = unsafe { self.kind.InvalidDescription };
11039 crate::error::PaymentError::InvalidDescription {
11040 err: ans.err.cst_decode(),
11041 }
11042 }
11043 11 => {
11044 let ans = unsafe { self.kind.InvalidInvoice };
11045 crate::error::PaymentError::InvalidInvoice {
11046 err: ans.err.cst_decode(),
11047 }
11048 }
11049 12 => crate::error::PaymentError::InvalidPreimage,
11050 13 => crate::error::PaymentError::PairsNotFound,
11051 14 => crate::error::PaymentError::PaymentTimeout,
11052 15 => crate::error::PaymentError::PersistError,
11053 16 => {
11054 let ans = unsafe { self.kind.ReceiveError };
11055 crate::error::PaymentError::ReceiveError {
11056 err: ans.err.cst_decode(),
11057 }
11058 }
11059 17 => {
11060 let ans = unsafe { self.kind.Refunded };
11061 crate::error::PaymentError::Refunded {
11062 err: ans.err.cst_decode(),
11063 refund_tx_id: ans.refund_tx_id.cst_decode(),
11064 }
11065 }
11066 18 => crate::error::PaymentError::SelfTransferNotSupported,
11067 19 => {
11068 let ans = unsafe { self.kind.SendError };
11069 crate::error::PaymentError::SendError {
11070 err: ans.err.cst_decode(),
11071 }
11072 }
11073 20 => {
11074 let ans = unsafe { self.kind.SignerError };
11075 crate::error::PaymentError::SignerError {
11076 err: ans.err.cst_decode(),
11077 }
11078 }
11079 _ => unreachable!(),
11080 }
11081 }
11082 }
11083 impl CstDecode<crate::model::PrepareBuyBitcoinRequest> for wire_cst_prepare_buy_bitcoin_request {
11084 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
11086 crate::model::PrepareBuyBitcoinRequest {
11087 provider: self.provider.cst_decode(),
11088 amount_sat: self.amount_sat.cst_decode(),
11089 }
11090 }
11091 }
11092 impl CstDecode<crate::model::PrepareBuyBitcoinResponse> for wire_cst_prepare_buy_bitcoin_response {
11093 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinResponse {
11095 crate::model::PrepareBuyBitcoinResponse {
11096 provider: self.provider.cst_decode(),
11097 amount_sat: self.amount_sat.cst_decode(),
11098 fees_sat: self.fees_sat.cst_decode(),
11099 }
11100 }
11101 }
11102 impl CstDecode<crate::model::PrepareLnUrlPayRequest> for wire_cst_prepare_ln_url_pay_request {
11103 fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
11105 crate::model::PrepareLnUrlPayRequest {
11106 data: self.data.cst_decode(),
11107 amount: self.amount.cst_decode(),
11108 bip353_address: self.bip353_address.cst_decode(),
11109 comment: self.comment.cst_decode(),
11110 validate_success_action_url: self.validate_success_action_url.cst_decode(),
11111 }
11112 }
11113 }
11114 impl CstDecode<crate::model::PrepareLnUrlPayResponse> for wire_cst_prepare_ln_url_pay_response {
11115 fn cst_decode(self) -> crate::model::PrepareLnUrlPayResponse {
11117 crate::model::PrepareLnUrlPayResponse {
11118 destination: self.destination.cst_decode(),
11119 fees_sat: self.fees_sat.cst_decode(),
11120 data: self.data.cst_decode(),
11121 comment: self.comment.cst_decode(),
11122 success_action: self.success_action.cst_decode(),
11123 }
11124 }
11125 }
11126 impl CstDecode<crate::model::PreparePayOnchainRequest> for wire_cst_prepare_pay_onchain_request {
11127 fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
11129 crate::model::PreparePayOnchainRequest {
11130 amount: self.amount.cst_decode(),
11131 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11132 }
11133 }
11134 }
11135 impl CstDecode<crate::model::PreparePayOnchainResponse> for wire_cst_prepare_pay_onchain_response {
11136 fn cst_decode(self) -> crate::model::PreparePayOnchainResponse {
11138 crate::model::PreparePayOnchainResponse {
11139 receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
11140 claim_fees_sat: self.claim_fees_sat.cst_decode(),
11141 total_fees_sat: self.total_fees_sat.cst_decode(),
11142 }
11143 }
11144 }
11145 impl CstDecode<crate::model::PrepareReceiveRequest> for wire_cst_prepare_receive_request {
11146 fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
11148 crate::model::PrepareReceiveRequest {
11149 payment_method: self.payment_method.cst_decode(),
11150 amount: self.amount.cst_decode(),
11151 }
11152 }
11153 }
11154 impl CstDecode<crate::model::PrepareReceiveResponse> for wire_cst_prepare_receive_response {
11155 fn cst_decode(self) -> crate::model::PrepareReceiveResponse {
11157 crate::model::PrepareReceiveResponse {
11158 payment_method: self.payment_method.cst_decode(),
11159 amount: self.amount.cst_decode(),
11160 fees_sat: self.fees_sat.cst_decode(),
11161 min_payer_amount_sat: self.min_payer_amount_sat.cst_decode(),
11162 max_payer_amount_sat: self.max_payer_amount_sat.cst_decode(),
11163 swapper_feerate: self.swapper_feerate.cst_decode(),
11164 }
11165 }
11166 }
11167 impl CstDecode<crate::model::PrepareRefundRequest> for wire_cst_prepare_refund_request {
11168 fn cst_decode(self) -> crate::model::PrepareRefundRequest {
11170 crate::model::PrepareRefundRequest {
11171 swap_address: self.swap_address.cst_decode(),
11172 refund_address: self.refund_address.cst_decode(),
11173 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11174 }
11175 }
11176 }
11177 impl CstDecode<crate::model::PrepareRefundResponse> for wire_cst_prepare_refund_response {
11178 fn cst_decode(self) -> crate::model::PrepareRefundResponse {
11180 crate::model::PrepareRefundResponse {
11181 tx_vsize: self.tx_vsize.cst_decode(),
11182 tx_fee_sat: self.tx_fee_sat.cst_decode(),
11183 last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11184 }
11185 }
11186 }
11187 impl CstDecode<crate::model::PrepareSendRequest> for wire_cst_prepare_send_request {
11188 fn cst_decode(self) -> crate::model::PrepareSendRequest {
11190 crate::model::PrepareSendRequest {
11191 destination: self.destination.cst_decode(),
11192 amount: self.amount.cst_decode(),
11193 }
11194 }
11195 }
11196 impl CstDecode<crate::model::PrepareSendResponse> for wire_cst_prepare_send_response {
11197 fn cst_decode(self) -> crate::model::PrepareSendResponse {
11199 crate::model::PrepareSendResponse {
11200 destination: self.destination.cst_decode(),
11201 fees_sat: self.fees_sat.cst_decode(),
11202 estimated_asset_fees: self.estimated_asset_fees.cst_decode(),
11203 }
11204 }
11205 }
11206 impl CstDecode<crate::bindings::Rate> for wire_cst_rate {
11207 fn cst_decode(self) -> crate::bindings::Rate {
11209 crate::bindings::Rate {
11210 coin: self.coin.cst_decode(),
11211 value: self.value.cst_decode(),
11212 }
11213 }
11214 }
11215 impl CstDecode<crate::model::ReceiveAmount> for wire_cst_receive_amount {
11216 fn cst_decode(self) -> crate::model::ReceiveAmount {
11218 match self.tag {
11219 0 => {
11220 let ans = unsafe { self.kind.Bitcoin };
11221 crate::model::ReceiveAmount::Bitcoin {
11222 payer_amount_sat: ans.payer_amount_sat.cst_decode(),
11223 }
11224 }
11225 1 => {
11226 let ans = unsafe { self.kind.Asset };
11227 crate::model::ReceiveAmount::Asset {
11228 asset_id: ans.asset_id.cst_decode(),
11229 payer_amount: ans.payer_amount.cst_decode(),
11230 }
11231 }
11232 _ => unreachable!(),
11233 }
11234 }
11235 }
11236 impl CstDecode<crate::model::ReceivePaymentRequest> for wire_cst_receive_payment_request {
11237 fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
11239 crate::model::ReceivePaymentRequest {
11240 prepare_response: self.prepare_response.cst_decode(),
11241 description: self.description.cst_decode(),
11242 use_description_hash: self.use_description_hash.cst_decode(),
11243 }
11244 }
11245 }
11246 impl CstDecode<crate::model::ReceivePaymentResponse> for wire_cst_receive_payment_response {
11247 fn cst_decode(self) -> crate::model::ReceivePaymentResponse {
11249 crate::model::ReceivePaymentResponse {
11250 destination: self.destination.cst_decode(),
11251 }
11252 }
11253 }
11254 impl CstDecode<crate::model::RecommendedFees> for wire_cst_recommended_fees {
11255 fn cst_decode(self) -> crate::model::RecommendedFees {
11257 crate::model::RecommendedFees {
11258 fastest_fee: self.fastest_fee.cst_decode(),
11259 half_hour_fee: self.half_hour_fee.cst_decode(),
11260 hour_fee: self.hour_fee.cst_decode(),
11261 economy_fee: self.economy_fee.cst_decode(),
11262 minimum_fee: self.minimum_fee.cst_decode(),
11263 }
11264 }
11265 }
11266 impl CstDecode<crate::model::RefundRequest> for wire_cst_refund_request {
11267 fn cst_decode(self) -> crate::model::RefundRequest {
11269 crate::model::RefundRequest {
11270 swap_address: self.swap_address.cst_decode(),
11271 refund_address: self.refund_address.cst_decode(),
11272 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11273 }
11274 }
11275 }
11276 impl CstDecode<crate::model::RefundResponse> for wire_cst_refund_response {
11277 fn cst_decode(self) -> crate::model::RefundResponse {
11279 crate::model::RefundResponse {
11280 refund_tx_id: self.refund_tx_id.cst_decode(),
11281 }
11282 }
11283 }
11284 impl CstDecode<crate::model::RefundableSwap> for wire_cst_refundable_swap {
11285 fn cst_decode(self) -> crate::model::RefundableSwap {
11287 crate::model::RefundableSwap {
11288 swap_address: self.swap_address.cst_decode(),
11289 timestamp: self.timestamp.cst_decode(),
11290 amount_sat: self.amount_sat.cst_decode(),
11291 last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11292 }
11293 }
11294 }
11295 impl CstDecode<crate::model::RestoreRequest> for wire_cst_restore_request {
11296 fn cst_decode(self) -> crate::model::RestoreRequest {
11298 crate::model::RestoreRequest {
11299 backup_path: self.backup_path.cst_decode(),
11300 }
11301 }
11302 }
11303 impl CstDecode<crate::bindings::RouteHint> for wire_cst_route_hint {
11304 fn cst_decode(self) -> crate::bindings::RouteHint {
11306 crate::bindings::RouteHint {
11307 hops: self.hops.cst_decode(),
11308 }
11309 }
11310 }
11311 impl CstDecode<crate::bindings::RouteHintHop> for wire_cst_route_hint_hop {
11312 fn cst_decode(self) -> crate::bindings::RouteHintHop {
11314 crate::bindings::RouteHintHop {
11315 src_node_id: self.src_node_id.cst_decode(),
11316 short_channel_id: self.short_channel_id.cst_decode(),
11317 fees_base_msat: self.fees_base_msat.cst_decode(),
11318 fees_proportional_millionths: self.fees_proportional_millionths.cst_decode(),
11319 cltv_expiry_delta: self.cltv_expiry_delta.cst_decode(),
11320 htlc_minimum_msat: self.htlc_minimum_msat.cst_decode(),
11321 htlc_maximum_msat: self.htlc_maximum_msat.cst_decode(),
11322 }
11323 }
11324 }
11325 impl CstDecode<crate::error::SdkError> for wire_cst_sdk_error {
11326 fn cst_decode(self) -> crate::error::SdkError {
11328 match self.tag {
11329 0 => crate::error::SdkError::AlreadyStarted,
11330 1 => {
11331 let ans = unsafe { self.kind.Generic };
11332 crate::error::SdkError::Generic {
11333 err: ans.err.cst_decode(),
11334 }
11335 }
11336 2 => crate::error::SdkError::NotStarted,
11337 3 => {
11338 let ans = unsafe { self.kind.ServiceConnectivity };
11339 crate::error::SdkError::ServiceConnectivity {
11340 err: ans.err.cst_decode(),
11341 }
11342 }
11343 _ => unreachable!(),
11344 }
11345 }
11346 }
11347 impl CstDecode<crate::model::SdkEvent> for wire_cst_sdk_event {
11348 fn cst_decode(self) -> crate::model::SdkEvent {
11350 match self.tag {
11351 0 => {
11352 let ans = unsafe { self.kind.PaymentFailed };
11353 crate::model::SdkEvent::PaymentFailed {
11354 details: ans.details.cst_decode(),
11355 }
11356 }
11357 1 => {
11358 let ans = unsafe { self.kind.PaymentPending };
11359 crate::model::SdkEvent::PaymentPending {
11360 details: ans.details.cst_decode(),
11361 }
11362 }
11363 2 => {
11364 let ans = unsafe { self.kind.PaymentRefundable };
11365 crate::model::SdkEvent::PaymentRefundable {
11366 details: ans.details.cst_decode(),
11367 }
11368 }
11369 3 => {
11370 let ans = unsafe { self.kind.PaymentRefunded };
11371 crate::model::SdkEvent::PaymentRefunded {
11372 details: ans.details.cst_decode(),
11373 }
11374 }
11375 4 => {
11376 let ans = unsafe { self.kind.PaymentRefundPending };
11377 crate::model::SdkEvent::PaymentRefundPending {
11378 details: ans.details.cst_decode(),
11379 }
11380 }
11381 5 => {
11382 let ans = unsafe { self.kind.PaymentSucceeded };
11383 crate::model::SdkEvent::PaymentSucceeded {
11384 details: ans.details.cst_decode(),
11385 }
11386 }
11387 6 => {
11388 let ans = unsafe { self.kind.PaymentWaitingConfirmation };
11389 crate::model::SdkEvent::PaymentWaitingConfirmation {
11390 details: ans.details.cst_decode(),
11391 }
11392 }
11393 7 => {
11394 let ans = unsafe { self.kind.PaymentWaitingFeeAcceptance };
11395 crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
11396 details: ans.details.cst_decode(),
11397 }
11398 }
11399 8 => crate::model::SdkEvent::Synced,
11400 9 => {
11401 let ans = unsafe { self.kind.DataSynced };
11402 crate::model::SdkEvent::DataSynced {
11403 did_pull_new_records: ans.did_pull_new_records.cst_decode(),
11404 }
11405 }
11406 _ => unreachable!(),
11407 }
11408 }
11409 }
11410 impl CstDecode<crate::model::SendDestination> for wire_cst_send_destination {
11411 fn cst_decode(self) -> crate::model::SendDestination {
11413 match self.tag {
11414 0 => {
11415 let ans = unsafe { self.kind.LiquidAddress };
11416 crate::model::SendDestination::LiquidAddress {
11417 address_data: ans.address_data.cst_decode(),
11418 bip353_address: ans.bip353_address.cst_decode(),
11419 }
11420 }
11421 1 => {
11422 let ans = unsafe { self.kind.Bolt11 };
11423 crate::model::SendDestination::Bolt11 {
11424 invoice: ans.invoice.cst_decode(),
11425 bip353_address: ans.bip353_address.cst_decode(),
11426 }
11427 }
11428 2 => {
11429 let ans = unsafe { self.kind.Bolt12 };
11430 crate::model::SendDestination::Bolt12 {
11431 offer: ans.offer.cst_decode(),
11432 receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11433 bip353_address: ans.bip353_address.cst_decode(),
11434 }
11435 }
11436 _ => unreachable!(),
11437 }
11438 }
11439 }
11440 impl CstDecode<crate::model::SendPaymentRequest> for wire_cst_send_payment_request {
11441 fn cst_decode(self) -> crate::model::SendPaymentRequest {
11443 crate::model::SendPaymentRequest {
11444 prepare_response: self.prepare_response.cst_decode(),
11445 use_asset_fees: self.use_asset_fees.cst_decode(),
11446 }
11447 }
11448 }
11449 impl CstDecode<crate::model::SendPaymentResponse> for wire_cst_send_payment_response {
11450 fn cst_decode(self) -> crate::model::SendPaymentResponse {
11452 crate::model::SendPaymentResponse {
11453 payment: self.payment.cst_decode(),
11454 }
11455 }
11456 }
11457 impl CstDecode<crate::model::SignMessageRequest> for wire_cst_sign_message_request {
11458 fn cst_decode(self) -> crate::model::SignMessageRequest {
11460 crate::model::SignMessageRequest {
11461 message: self.message.cst_decode(),
11462 }
11463 }
11464 }
11465 impl CstDecode<crate::model::SignMessageResponse> for wire_cst_sign_message_response {
11466 fn cst_decode(self) -> crate::model::SignMessageResponse {
11468 crate::model::SignMessageResponse {
11469 signature: self.signature.cst_decode(),
11470 }
11471 }
11472 }
11473 impl CstDecode<crate::bindings::SuccessAction> for wire_cst_success_action {
11474 fn cst_decode(self) -> crate::bindings::SuccessAction {
11476 match self.tag {
11477 0 => {
11478 let ans = unsafe { self.kind.Aes };
11479 crate::bindings::SuccessAction::Aes {
11480 data: ans.data.cst_decode(),
11481 }
11482 }
11483 1 => {
11484 let ans = unsafe { self.kind.Message };
11485 crate::bindings::SuccessAction::Message {
11486 data: ans.data.cst_decode(),
11487 }
11488 }
11489 2 => {
11490 let ans = unsafe { self.kind.Url };
11491 crate::bindings::SuccessAction::Url {
11492 data: ans.data.cst_decode(),
11493 }
11494 }
11495 _ => unreachable!(),
11496 }
11497 }
11498 }
11499 impl CstDecode<crate::bindings::SuccessActionProcessed> for wire_cst_success_action_processed {
11500 fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
11502 match self.tag {
11503 0 => {
11504 let ans = unsafe { self.kind.Aes };
11505 crate::bindings::SuccessActionProcessed::Aes {
11506 result: ans.result.cst_decode(),
11507 }
11508 }
11509 1 => {
11510 let ans = unsafe { self.kind.Message };
11511 crate::bindings::SuccessActionProcessed::Message {
11512 data: ans.data.cst_decode(),
11513 }
11514 }
11515 2 => {
11516 let ans = unsafe { self.kind.Url };
11517 crate::bindings::SuccessActionProcessed::Url {
11518 data: ans.data.cst_decode(),
11519 }
11520 }
11521 _ => unreachable!(),
11522 }
11523 }
11524 }
11525 impl CstDecode<crate::bindings::Symbol> for wire_cst_symbol {
11526 fn cst_decode(self) -> crate::bindings::Symbol {
11528 crate::bindings::Symbol {
11529 grapheme: self.grapheme.cst_decode(),
11530 template: self.template.cst_decode(),
11531 rtl: self.rtl.cst_decode(),
11532 position: self.position.cst_decode(),
11533 }
11534 }
11535 }
11536 impl CstDecode<crate::bindings::UrlSuccessActionData> for wire_cst_url_success_action_data {
11537 fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
11539 crate::bindings::UrlSuccessActionData {
11540 description: self.description.cst_decode(),
11541 url: self.url.cst_decode(),
11542 matches_callback_domain: self.matches_callback_domain.cst_decode(),
11543 }
11544 }
11545 }
11546 impl CstDecode<crate::model::WalletInfo> for wire_cst_wallet_info {
11547 fn cst_decode(self) -> crate::model::WalletInfo {
11549 crate::model::WalletInfo {
11550 balance_sat: self.balance_sat.cst_decode(),
11551 pending_send_sat: self.pending_send_sat.cst_decode(),
11552 pending_receive_sat: self.pending_receive_sat.cst_decode(),
11553 fingerprint: self.fingerprint.cst_decode(),
11554 pubkey: self.pubkey.cst_decode(),
11555 asset_balances: self.asset_balances.cst_decode(),
11556 }
11557 }
11558 }
11559 impl NewWithNullPtr for wire_cst_accept_payment_proposed_fees_request {
11560 fn new_with_null_ptr() -> Self {
11561 Self {
11562 response: Default::default(),
11563 }
11564 }
11565 }
11566 impl Default for wire_cst_accept_payment_proposed_fees_request {
11567 fn default() -> Self {
11568 Self::new_with_null_ptr()
11569 }
11570 }
11571 impl NewWithNullPtr for wire_cst_aes_success_action_data {
11572 fn new_with_null_ptr() -> Self {
11573 Self {
11574 description: core::ptr::null_mut(),
11575 ciphertext: core::ptr::null_mut(),
11576 iv: core::ptr::null_mut(),
11577 }
11578 }
11579 }
11580 impl Default for wire_cst_aes_success_action_data {
11581 fn default() -> Self {
11582 Self::new_with_null_ptr()
11583 }
11584 }
11585 impl NewWithNullPtr for wire_cst_aes_success_action_data_decrypted {
11586 fn new_with_null_ptr() -> Self {
11587 Self {
11588 description: core::ptr::null_mut(),
11589 plaintext: core::ptr::null_mut(),
11590 }
11591 }
11592 }
11593 impl Default for wire_cst_aes_success_action_data_decrypted {
11594 fn default() -> Self {
11595 Self::new_with_null_ptr()
11596 }
11597 }
11598 impl NewWithNullPtr for wire_cst_aes_success_action_data_result {
11599 fn new_with_null_ptr() -> Self {
11600 Self {
11601 tag: -1,
11602 kind: AesSuccessActionDataResultKind { nil__: () },
11603 }
11604 }
11605 }
11606 impl Default for wire_cst_aes_success_action_data_result {
11607 fn default() -> Self {
11608 Self::new_with_null_ptr()
11609 }
11610 }
11611 impl NewWithNullPtr for wire_cst_amount {
11612 fn new_with_null_ptr() -> Self {
11613 Self {
11614 tag: -1,
11615 kind: AmountKind { nil__: () },
11616 }
11617 }
11618 }
11619 impl Default for wire_cst_amount {
11620 fn default() -> Self {
11621 Self::new_with_null_ptr()
11622 }
11623 }
11624 impl NewWithNullPtr for wire_cst_asset_balance {
11625 fn new_with_null_ptr() -> Self {
11626 Self {
11627 asset_id: core::ptr::null_mut(),
11628 balance_sat: Default::default(),
11629 name: core::ptr::null_mut(),
11630 ticker: core::ptr::null_mut(),
11631 balance: core::ptr::null_mut(),
11632 }
11633 }
11634 }
11635 impl Default for wire_cst_asset_balance {
11636 fn default() -> Self {
11637 Self::new_with_null_ptr()
11638 }
11639 }
11640 impl NewWithNullPtr for wire_cst_asset_info {
11641 fn new_with_null_ptr() -> Self {
11642 Self {
11643 name: core::ptr::null_mut(),
11644 ticker: core::ptr::null_mut(),
11645 amount: Default::default(),
11646 fees: core::ptr::null_mut(),
11647 }
11648 }
11649 }
11650 impl Default for wire_cst_asset_info {
11651 fn default() -> Self {
11652 Self::new_with_null_ptr()
11653 }
11654 }
11655 impl NewWithNullPtr for wire_cst_asset_metadata {
11656 fn new_with_null_ptr() -> Self {
11657 Self {
11658 asset_id: core::ptr::null_mut(),
11659 name: core::ptr::null_mut(),
11660 ticker: core::ptr::null_mut(),
11661 precision: Default::default(),
11662 fiat_id: core::ptr::null_mut(),
11663 }
11664 }
11665 }
11666 impl Default for wire_cst_asset_metadata {
11667 fn default() -> Self {
11668 Self::new_with_null_ptr()
11669 }
11670 }
11671 impl NewWithNullPtr for wire_cst_backup_request {
11672 fn new_with_null_ptr() -> Self {
11673 Self {
11674 backup_path: core::ptr::null_mut(),
11675 }
11676 }
11677 }
11678 impl Default for wire_cst_backup_request {
11679 fn default() -> Self {
11680 Self::new_with_null_ptr()
11681 }
11682 }
11683 impl NewWithNullPtr for wire_cst_binding_event_listener {
11684 fn new_with_null_ptr() -> Self {
11685 Self {
11686 stream: core::ptr::null_mut(),
11687 }
11688 }
11689 }
11690 impl Default for wire_cst_binding_event_listener {
11691 fn default() -> Self {
11692 Self::new_with_null_ptr()
11693 }
11694 }
11695 impl NewWithNullPtr for wire_cst_bitcoin_address_data {
11696 fn new_with_null_ptr() -> Self {
11697 Self {
11698 address: core::ptr::null_mut(),
11699 network: Default::default(),
11700 amount_sat: core::ptr::null_mut(),
11701 label: core::ptr::null_mut(),
11702 message: core::ptr::null_mut(),
11703 }
11704 }
11705 }
11706 impl Default for wire_cst_bitcoin_address_data {
11707 fn default() -> Self {
11708 Self::new_with_null_ptr()
11709 }
11710 }
11711 impl NewWithNullPtr for wire_cst_blockchain_explorer {
11712 fn new_with_null_ptr() -> Self {
11713 Self {
11714 tag: -1,
11715 kind: BlockchainExplorerKind { nil__: () },
11716 }
11717 }
11718 }
11719 impl Default for wire_cst_blockchain_explorer {
11720 fn default() -> Self {
11721 Self::new_with_null_ptr()
11722 }
11723 }
11724 impl NewWithNullPtr for wire_cst_blockchain_info {
11725 fn new_with_null_ptr() -> Self {
11726 Self {
11727 liquid_tip: Default::default(),
11728 bitcoin_tip: Default::default(),
11729 }
11730 }
11731 }
11732 impl Default for wire_cst_blockchain_info {
11733 fn default() -> Self {
11734 Self::new_with_null_ptr()
11735 }
11736 }
11737 impl NewWithNullPtr for wire_cst_buy_bitcoin_request {
11738 fn new_with_null_ptr() -> Self {
11739 Self {
11740 prepare_response: Default::default(),
11741 redirect_url: core::ptr::null_mut(),
11742 }
11743 }
11744 }
11745 impl Default for wire_cst_buy_bitcoin_request {
11746 fn default() -> Self {
11747 Self::new_with_null_ptr()
11748 }
11749 }
11750 impl NewWithNullPtr for wire_cst_check_message_request {
11751 fn new_with_null_ptr() -> Self {
11752 Self {
11753 message: core::ptr::null_mut(),
11754 pubkey: core::ptr::null_mut(),
11755 signature: core::ptr::null_mut(),
11756 }
11757 }
11758 }
11759 impl Default for wire_cst_check_message_request {
11760 fn default() -> Self {
11761 Self::new_with_null_ptr()
11762 }
11763 }
11764 impl NewWithNullPtr for wire_cst_check_message_response {
11765 fn new_with_null_ptr() -> Self {
11766 Self {
11767 is_valid: Default::default(),
11768 }
11769 }
11770 }
11771 impl Default for wire_cst_check_message_response {
11772 fn default() -> Self {
11773 Self::new_with_null_ptr()
11774 }
11775 }
11776 impl NewWithNullPtr for wire_cst_config {
11777 fn new_with_null_ptr() -> Self {
11778 Self {
11779 liquid_explorer: Default::default(),
11780 bitcoin_explorer: Default::default(),
11781 working_dir: core::ptr::null_mut(),
11782 cache_dir: core::ptr::null_mut(),
11783 network: Default::default(),
11784 payment_timeout_sec: Default::default(),
11785 sync_service_url: core::ptr::null_mut(),
11786 zero_conf_max_amount_sat: core::ptr::null_mut(),
11787 breez_api_key: core::ptr::null_mut(),
11788 external_input_parsers: core::ptr::null_mut(),
11789 use_default_external_input_parsers: Default::default(),
11790 onchain_fee_rate_leeway_sat_per_vbyte: core::ptr::null_mut(),
11791 asset_metadata: core::ptr::null_mut(),
11792 sideswap_api_key: core::ptr::null_mut(),
11793 }
11794 }
11795 }
11796 impl Default for wire_cst_config {
11797 fn default() -> Self {
11798 Self::new_with_null_ptr()
11799 }
11800 }
11801 impl NewWithNullPtr for wire_cst_connect_request {
11802 fn new_with_null_ptr() -> Self {
11803 Self {
11804 config: Default::default(),
11805 mnemonic: core::ptr::null_mut(),
11806 passphrase: core::ptr::null_mut(),
11807 seed: core::ptr::null_mut(),
11808 }
11809 }
11810 }
11811 impl Default for wire_cst_connect_request {
11812 fn default() -> Self {
11813 Self::new_with_null_ptr()
11814 }
11815 }
11816 impl NewWithNullPtr for wire_cst_currency_info {
11817 fn new_with_null_ptr() -> Self {
11818 Self {
11819 name: core::ptr::null_mut(),
11820 fraction_size: Default::default(),
11821 spacing: core::ptr::null_mut(),
11822 symbol: core::ptr::null_mut(),
11823 uniq_symbol: core::ptr::null_mut(),
11824 localized_name: core::ptr::null_mut(),
11825 locale_overrides: core::ptr::null_mut(),
11826 }
11827 }
11828 }
11829 impl Default for wire_cst_currency_info {
11830 fn default() -> Self {
11831 Self::new_with_null_ptr()
11832 }
11833 }
11834 impl NewWithNullPtr for wire_cst_external_input_parser {
11835 fn new_with_null_ptr() -> Self {
11836 Self {
11837 provider_id: core::ptr::null_mut(),
11838 input_regex: core::ptr::null_mut(),
11839 parser_url: core::ptr::null_mut(),
11840 }
11841 }
11842 }
11843 impl Default for wire_cst_external_input_parser {
11844 fn default() -> Self {
11845 Self::new_with_null_ptr()
11846 }
11847 }
11848 impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_request {
11849 fn new_with_null_ptr() -> Self {
11850 Self {
11851 swap_id: core::ptr::null_mut(),
11852 }
11853 }
11854 }
11855 impl Default for wire_cst_fetch_payment_proposed_fees_request {
11856 fn default() -> Self {
11857 Self::new_with_null_ptr()
11858 }
11859 }
11860 impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_response {
11861 fn new_with_null_ptr() -> Self {
11862 Self {
11863 swap_id: core::ptr::null_mut(),
11864 fees_sat: Default::default(),
11865 payer_amount_sat: Default::default(),
11866 receiver_amount_sat: Default::default(),
11867 }
11868 }
11869 }
11870 impl Default for wire_cst_fetch_payment_proposed_fees_response {
11871 fn default() -> Self {
11872 Self::new_with_null_ptr()
11873 }
11874 }
11875 impl NewWithNullPtr for wire_cst_fiat_currency {
11876 fn new_with_null_ptr() -> Self {
11877 Self {
11878 id: core::ptr::null_mut(),
11879 info: Default::default(),
11880 }
11881 }
11882 }
11883 impl Default for wire_cst_fiat_currency {
11884 fn default() -> Self {
11885 Self::new_with_null_ptr()
11886 }
11887 }
11888 impl NewWithNullPtr for wire_cst_get_info_response {
11889 fn new_with_null_ptr() -> Self {
11890 Self {
11891 wallet_info: Default::default(),
11892 blockchain_info: Default::default(),
11893 }
11894 }
11895 }
11896 impl Default for wire_cst_get_info_response {
11897 fn default() -> Self {
11898 Self::new_with_null_ptr()
11899 }
11900 }
11901 impl NewWithNullPtr for wire_cst_get_payment_request {
11902 fn new_with_null_ptr() -> Self {
11903 Self {
11904 tag: -1,
11905 kind: GetPaymentRequestKind { nil__: () },
11906 }
11907 }
11908 }
11909 impl Default for wire_cst_get_payment_request {
11910 fn default() -> Self {
11911 Self::new_with_null_ptr()
11912 }
11913 }
11914 impl NewWithNullPtr for wire_cst_input_type {
11915 fn new_with_null_ptr() -> Self {
11916 Self {
11917 tag: -1,
11918 kind: InputTypeKind { nil__: () },
11919 }
11920 }
11921 }
11922 impl Default for wire_cst_input_type {
11923 fn default() -> Self {
11924 Self::new_with_null_ptr()
11925 }
11926 }
11927 impl NewWithNullPtr for wire_cst_lightning_payment_limits_response {
11928 fn new_with_null_ptr() -> Self {
11929 Self {
11930 send: Default::default(),
11931 receive: Default::default(),
11932 }
11933 }
11934 }
11935 impl Default for wire_cst_lightning_payment_limits_response {
11936 fn default() -> Self {
11937 Self::new_with_null_ptr()
11938 }
11939 }
11940 impl NewWithNullPtr for wire_cst_limits {
11941 fn new_with_null_ptr() -> Self {
11942 Self {
11943 min_sat: Default::default(),
11944 max_sat: Default::default(),
11945 max_zero_conf_sat: Default::default(),
11946 }
11947 }
11948 }
11949 impl Default for wire_cst_limits {
11950 fn default() -> Self {
11951 Self::new_with_null_ptr()
11952 }
11953 }
11954 impl NewWithNullPtr for wire_cst_liquid_address_data {
11955 fn new_with_null_ptr() -> Self {
11956 Self {
11957 address: core::ptr::null_mut(),
11958 network: Default::default(),
11959 asset_id: core::ptr::null_mut(),
11960 amount: core::ptr::null_mut(),
11961 amount_sat: core::ptr::null_mut(),
11962 label: core::ptr::null_mut(),
11963 message: core::ptr::null_mut(),
11964 }
11965 }
11966 }
11967 impl Default for wire_cst_liquid_address_data {
11968 fn default() -> Self {
11969 Self::new_with_null_ptr()
11970 }
11971 }
11972 impl NewWithNullPtr for wire_cst_list_payment_details {
11973 fn new_with_null_ptr() -> Self {
11974 Self {
11975 tag: -1,
11976 kind: ListPaymentDetailsKind { nil__: () },
11977 }
11978 }
11979 }
11980 impl Default for wire_cst_list_payment_details {
11981 fn default() -> Self {
11982 Self::new_with_null_ptr()
11983 }
11984 }
11985 impl NewWithNullPtr for wire_cst_list_payments_request {
11986 fn new_with_null_ptr() -> Self {
11987 Self {
11988 filters: core::ptr::null_mut(),
11989 states: core::ptr::null_mut(),
11990 from_timestamp: core::ptr::null_mut(),
11991 to_timestamp: core::ptr::null_mut(),
11992 offset: core::ptr::null_mut(),
11993 limit: core::ptr::null_mut(),
11994 details: core::ptr::null_mut(),
11995 sort_ascending: core::ptr::null_mut(),
11996 }
11997 }
11998 }
11999 impl Default for wire_cst_list_payments_request {
12000 fn default() -> Self {
12001 Self::new_with_null_ptr()
12002 }
12003 }
12004 impl NewWithNullPtr for wire_cst_ln_invoice {
12005 fn new_with_null_ptr() -> Self {
12006 Self {
12007 bolt11: core::ptr::null_mut(),
12008 network: Default::default(),
12009 payee_pubkey: core::ptr::null_mut(),
12010 payment_hash: core::ptr::null_mut(),
12011 description: core::ptr::null_mut(),
12012 description_hash: core::ptr::null_mut(),
12013 amount_msat: core::ptr::null_mut(),
12014 timestamp: Default::default(),
12015 expiry: Default::default(),
12016 routing_hints: core::ptr::null_mut(),
12017 payment_secret: core::ptr::null_mut(),
12018 min_final_cltv_expiry_delta: Default::default(),
12019 }
12020 }
12021 }
12022 impl Default for wire_cst_ln_invoice {
12023 fn default() -> Self {
12024 Self::new_with_null_ptr()
12025 }
12026 }
12027 impl NewWithNullPtr for wire_cst_ln_offer {
12028 fn new_with_null_ptr() -> Self {
12029 Self {
12030 offer: core::ptr::null_mut(),
12031 chains: core::ptr::null_mut(),
12032 min_amount: core::ptr::null_mut(),
12033 description: core::ptr::null_mut(),
12034 absolute_expiry: core::ptr::null_mut(),
12035 issuer: core::ptr::null_mut(),
12036 signing_pubkey: core::ptr::null_mut(),
12037 paths: core::ptr::null_mut(),
12038 }
12039 }
12040 }
12041 impl Default for wire_cst_ln_offer {
12042 fn default() -> Self {
12043 Self::new_with_null_ptr()
12044 }
12045 }
12046 impl NewWithNullPtr for wire_cst_ln_offer_blinded_path {
12047 fn new_with_null_ptr() -> Self {
12048 Self {
12049 blinded_hops: core::ptr::null_mut(),
12050 }
12051 }
12052 }
12053 impl Default for wire_cst_ln_offer_blinded_path {
12054 fn default() -> Self {
12055 Self::new_with_null_ptr()
12056 }
12057 }
12058 impl NewWithNullPtr for wire_cst_ln_url_auth_error {
12059 fn new_with_null_ptr() -> Self {
12060 Self {
12061 tag: -1,
12062 kind: LnUrlAuthErrorKind { nil__: () },
12063 }
12064 }
12065 }
12066 impl Default for wire_cst_ln_url_auth_error {
12067 fn default() -> Self {
12068 Self::new_with_null_ptr()
12069 }
12070 }
12071 impl NewWithNullPtr for wire_cst_ln_url_auth_request_data {
12072 fn new_with_null_ptr() -> Self {
12073 Self {
12074 k1: core::ptr::null_mut(),
12075 action: core::ptr::null_mut(),
12076 domain: core::ptr::null_mut(),
12077 url: core::ptr::null_mut(),
12078 }
12079 }
12080 }
12081 impl Default for wire_cst_ln_url_auth_request_data {
12082 fn default() -> Self {
12083 Self::new_with_null_ptr()
12084 }
12085 }
12086 impl NewWithNullPtr for wire_cst_ln_url_callback_status {
12087 fn new_with_null_ptr() -> Self {
12088 Self {
12089 tag: -1,
12090 kind: LnUrlCallbackStatusKind { nil__: () },
12091 }
12092 }
12093 }
12094 impl Default for wire_cst_ln_url_callback_status {
12095 fn default() -> Self {
12096 Self::new_with_null_ptr()
12097 }
12098 }
12099 impl NewWithNullPtr for wire_cst_ln_url_error_data {
12100 fn new_with_null_ptr() -> Self {
12101 Self {
12102 reason: core::ptr::null_mut(),
12103 }
12104 }
12105 }
12106 impl Default for wire_cst_ln_url_error_data {
12107 fn default() -> Self {
12108 Self::new_with_null_ptr()
12109 }
12110 }
12111 impl NewWithNullPtr for wire_cst_ln_url_info {
12112 fn new_with_null_ptr() -> Self {
12113 Self {
12114 ln_address: core::ptr::null_mut(),
12115 lnurl_pay_comment: core::ptr::null_mut(),
12116 lnurl_pay_domain: core::ptr::null_mut(),
12117 lnurl_pay_metadata: core::ptr::null_mut(),
12118 lnurl_pay_success_action: core::ptr::null_mut(),
12119 lnurl_pay_unprocessed_success_action: core::ptr::null_mut(),
12120 lnurl_withdraw_endpoint: core::ptr::null_mut(),
12121 }
12122 }
12123 }
12124 impl Default for wire_cst_ln_url_info {
12125 fn default() -> Self {
12126 Self::new_with_null_ptr()
12127 }
12128 }
12129 impl NewWithNullPtr for wire_cst_ln_url_pay_error {
12130 fn new_with_null_ptr() -> Self {
12131 Self {
12132 tag: -1,
12133 kind: LnUrlPayErrorKind { nil__: () },
12134 }
12135 }
12136 }
12137 impl Default for wire_cst_ln_url_pay_error {
12138 fn default() -> Self {
12139 Self::new_with_null_ptr()
12140 }
12141 }
12142 impl NewWithNullPtr for wire_cst_ln_url_pay_error_data {
12143 fn new_with_null_ptr() -> Self {
12144 Self {
12145 payment_hash: core::ptr::null_mut(),
12146 reason: core::ptr::null_mut(),
12147 }
12148 }
12149 }
12150 impl Default for wire_cst_ln_url_pay_error_data {
12151 fn default() -> Self {
12152 Self::new_with_null_ptr()
12153 }
12154 }
12155 impl NewWithNullPtr for wire_cst_ln_url_pay_request {
12156 fn new_with_null_ptr() -> Self {
12157 Self {
12158 prepare_response: Default::default(),
12159 }
12160 }
12161 }
12162 impl Default for wire_cst_ln_url_pay_request {
12163 fn default() -> Self {
12164 Self::new_with_null_ptr()
12165 }
12166 }
12167 impl NewWithNullPtr for wire_cst_ln_url_pay_request_data {
12168 fn new_with_null_ptr() -> Self {
12169 Self {
12170 callback: core::ptr::null_mut(),
12171 min_sendable: Default::default(),
12172 max_sendable: Default::default(),
12173 metadata_str: core::ptr::null_mut(),
12174 comment_allowed: Default::default(),
12175 domain: core::ptr::null_mut(),
12176 allows_nostr: Default::default(),
12177 nostr_pubkey: core::ptr::null_mut(),
12178 ln_address: core::ptr::null_mut(),
12179 }
12180 }
12181 }
12182 impl Default for wire_cst_ln_url_pay_request_data {
12183 fn default() -> Self {
12184 Self::new_with_null_ptr()
12185 }
12186 }
12187 impl NewWithNullPtr for wire_cst_ln_url_pay_result {
12188 fn new_with_null_ptr() -> Self {
12189 Self {
12190 tag: -1,
12191 kind: LnUrlPayResultKind { nil__: () },
12192 }
12193 }
12194 }
12195 impl Default for wire_cst_ln_url_pay_result {
12196 fn default() -> Self {
12197 Self::new_with_null_ptr()
12198 }
12199 }
12200 impl NewWithNullPtr for wire_cst_ln_url_pay_success_data {
12201 fn new_with_null_ptr() -> Self {
12202 Self {
12203 payment: Default::default(),
12204 success_action: core::ptr::null_mut(),
12205 }
12206 }
12207 }
12208 impl Default for wire_cst_ln_url_pay_success_data {
12209 fn default() -> Self {
12210 Self::new_with_null_ptr()
12211 }
12212 }
12213 impl NewWithNullPtr for wire_cst_ln_url_withdraw_error {
12214 fn new_with_null_ptr() -> Self {
12215 Self {
12216 tag: -1,
12217 kind: LnUrlWithdrawErrorKind { nil__: () },
12218 }
12219 }
12220 }
12221 impl Default for wire_cst_ln_url_withdraw_error {
12222 fn default() -> Self {
12223 Self::new_with_null_ptr()
12224 }
12225 }
12226 impl NewWithNullPtr for wire_cst_ln_url_withdraw_request {
12227 fn new_with_null_ptr() -> Self {
12228 Self {
12229 data: Default::default(),
12230 amount_msat: Default::default(),
12231 description: core::ptr::null_mut(),
12232 }
12233 }
12234 }
12235 impl Default for wire_cst_ln_url_withdraw_request {
12236 fn default() -> Self {
12237 Self::new_with_null_ptr()
12238 }
12239 }
12240 impl NewWithNullPtr for wire_cst_ln_url_withdraw_request_data {
12241 fn new_with_null_ptr() -> Self {
12242 Self {
12243 callback: core::ptr::null_mut(),
12244 k1: core::ptr::null_mut(),
12245 default_description: core::ptr::null_mut(),
12246 min_withdrawable: Default::default(),
12247 max_withdrawable: Default::default(),
12248 }
12249 }
12250 }
12251 impl Default for wire_cst_ln_url_withdraw_request_data {
12252 fn default() -> Self {
12253 Self::new_with_null_ptr()
12254 }
12255 }
12256 impl NewWithNullPtr for wire_cst_ln_url_withdraw_result {
12257 fn new_with_null_ptr() -> Self {
12258 Self {
12259 tag: -1,
12260 kind: LnUrlWithdrawResultKind { nil__: () },
12261 }
12262 }
12263 }
12264 impl Default for wire_cst_ln_url_withdraw_result {
12265 fn default() -> Self {
12266 Self::new_with_null_ptr()
12267 }
12268 }
12269 impl NewWithNullPtr for wire_cst_ln_url_withdraw_success_data {
12270 fn new_with_null_ptr() -> Self {
12271 Self {
12272 invoice: Default::default(),
12273 }
12274 }
12275 }
12276 impl Default for wire_cst_ln_url_withdraw_success_data {
12277 fn default() -> Self {
12278 Self::new_with_null_ptr()
12279 }
12280 }
12281 impl NewWithNullPtr for wire_cst_locale_overrides {
12282 fn new_with_null_ptr() -> Self {
12283 Self {
12284 locale: core::ptr::null_mut(),
12285 spacing: core::ptr::null_mut(),
12286 symbol: Default::default(),
12287 }
12288 }
12289 }
12290 impl Default for wire_cst_locale_overrides {
12291 fn default() -> Self {
12292 Self::new_with_null_ptr()
12293 }
12294 }
12295 impl NewWithNullPtr for wire_cst_localized_name {
12296 fn new_with_null_ptr() -> Self {
12297 Self {
12298 locale: core::ptr::null_mut(),
12299 name: core::ptr::null_mut(),
12300 }
12301 }
12302 }
12303 impl Default for wire_cst_localized_name {
12304 fn default() -> Self {
12305 Self::new_with_null_ptr()
12306 }
12307 }
12308 impl NewWithNullPtr for wire_cst_log_entry {
12309 fn new_with_null_ptr() -> Self {
12310 Self {
12311 line: core::ptr::null_mut(),
12312 level: core::ptr::null_mut(),
12313 }
12314 }
12315 }
12316 impl Default for wire_cst_log_entry {
12317 fn default() -> Self {
12318 Self::new_with_null_ptr()
12319 }
12320 }
12321 impl NewWithNullPtr for wire_cst_message_success_action_data {
12322 fn new_with_null_ptr() -> Self {
12323 Self {
12324 message: core::ptr::null_mut(),
12325 }
12326 }
12327 }
12328 impl Default for wire_cst_message_success_action_data {
12329 fn default() -> Self {
12330 Self::new_with_null_ptr()
12331 }
12332 }
12333 impl NewWithNullPtr for wire_cst_onchain_payment_limits_response {
12334 fn new_with_null_ptr() -> Self {
12335 Self {
12336 send: Default::default(),
12337 receive: Default::default(),
12338 }
12339 }
12340 }
12341 impl Default for wire_cst_onchain_payment_limits_response {
12342 fn default() -> Self {
12343 Self::new_with_null_ptr()
12344 }
12345 }
12346 impl NewWithNullPtr for wire_cst_pay_amount {
12347 fn new_with_null_ptr() -> Self {
12348 Self {
12349 tag: -1,
12350 kind: PayAmountKind { nil__: () },
12351 }
12352 }
12353 }
12354 impl Default for wire_cst_pay_amount {
12355 fn default() -> Self {
12356 Self::new_with_null_ptr()
12357 }
12358 }
12359 impl NewWithNullPtr for wire_cst_pay_onchain_request {
12360 fn new_with_null_ptr() -> Self {
12361 Self {
12362 address: core::ptr::null_mut(),
12363 prepare_response: Default::default(),
12364 }
12365 }
12366 }
12367 impl Default for wire_cst_pay_onchain_request {
12368 fn default() -> Self {
12369 Self::new_with_null_ptr()
12370 }
12371 }
12372 impl NewWithNullPtr for wire_cst_payment {
12373 fn new_with_null_ptr() -> Self {
12374 Self {
12375 destination: core::ptr::null_mut(),
12376 tx_id: core::ptr::null_mut(),
12377 unblinding_data: core::ptr::null_mut(),
12378 timestamp: Default::default(),
12379 amount_sat: Default::default(),
12380 fees_sat: Default::default(),
12381 swapper_fees_sat: core::ptr::null_mut(),
12382 payment_type: Default::default(),
12383 status: Default::default(),
12384 details: Default::default(),
12385 }
12386 }
12387 }
12388 impl Default for wire_cst_payment {
12389 fn default() -> Self {
12390 Self::new_with_null_ptr()
12391 }
12392 }
12393 impl NewWithNullPtr for wire_cst_payment_details {
12394 fn new_with_null_ptr() -> Self {
12395 Self {
12396 tag: -1,
12397 kind: PaymentDetailsKind { nil__: () },
12398 }
12399 }
12400 }
12401 impl Default for wire_cst_payment_details {
12402 fn default() -> Self {
12403 Self::new_with_null_ptr()
12404 }
12405 }
12406 impl NewWithNullPtr for wire_cst_payment_error {
12407 fn new_with_null_ptr() -> Self {
12408 Self {
12409 tag: -1,
12410 kind: PaymentErrorKind { nil__: () },
12411 }
12412 }
12413 }
12414 impl Default for wire_cst_payment_error {
12415 fn default() -> Self {
12416 Self::new_with_null_ptr()
12417 }
12418 }
12419 impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_request {
12420 fn new_with_null_ptr() -> Self {
12421 Self {
12422 provider: Default::default(),
12423 amount_sat: Default::default(),
12424 }
12425 }
12426 }
12427 impl Default for wire_cst_prepare_buy_bitcoin_request {
12428 fn default() -> Self {
12429 Self::new_with_null_ptr()
12430 }
12431 }
12432 impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_response {
12433 fn new_with_null_ptr() -> Self {
12434 Self {
12435 provider: Default::default(),
12436 amount_sat: Default::default(),
12437 fees_sat: Default::default(),
12438 }
12439 }
12440 }
12441 impl Default for wire_cst_prepare_buy_bitcoin_response {
12442 fn default() -> Self {
12443 Self::new_with_null_ptr()
12444 }
12445 }
12446 impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_request {
12447 fn new_with_null_ptr() -> Self {
12448 Self {
12449 data: Default::default(),
12450 amount: Default::default(),
12451 bip353_address: core::ptr::null_mut(),
12452 comment: core::ptr::null_mut(),
12453 validate_success_action_url: core::ptr::null_mut(),
12454 }
12455 }
12456 }
12457 impl Default for wire_cst_prepare_ln_url_pay_request {
12458 fn default() -> Self {
12459 Self::new_with_null_ptr()
12460 }
12461 }
12462 impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_response {
12463 fn new_with_null_ptr() -> Self {
12464 Self {
12465 destination: Default::default(),
12466 fees_sat: Default::default(),
12467 data: Default::default(),
12468 comment: core::ptr::null_mut(),
12469 success_action: core::ptr::null_mut(),
12470 }
12471 }
12472 }
12473 impl Default for wire_cst_prepare_ln_url_pay_response {
12474 fn default() -> Self {
12475 Self::new_with_null_ptr()
12476 }
12477 }
12478 impl NewWithNullPtr for wire_cst_prepare_pay_onchain_request {
12479 fn new_with_null_ptr() -> Self {
12480 Self {
12481 amount: Default::default(),
12482 fee_rate_sat_per_vbyte: core::ptr::null_mut(),
12483 }
12484 }
12485 }
12486 impl Default for wire_cst_prepare_pay_onchain_request {
12487 fn default() -> Self {
12488 Self::new_with_null_ptr()
12489 }
12490 }
12491 impl NewWithNullPtr for wire_cst_prepare_pay_onchain_response {
12492 fn new_with_null_ptr() -> Self {
12493 Self {
12494 receiver_amount_sat: Default::default(),
12495 claim_fees_sat: Default::default(),
12496 total_fees_sat: Default::default(),
12497 }
12498 }
12499 }
12500 impl Default for wire_cst_prepare_pay_onchain_response {
12501 fn default() -> Self {
12502 Self::new_with_null_ptr()
12503 }
12504 }
12505 impl NewWithNullPtr for wire_cst_prepare_receive_request {
12506 fn new_with_null_ptr() -> Self {
12507 Self {
12508 payment_method: Default::default(),
12509 amount: core::ptr::null_mut(),
12510 }
12511 }
12512 }
12513 impl Default for wire_cst_prepare_receive_request {
12514 fn default() -> Self {
12515 Self::new_with_null_ptr()
12516 }
12517 }
12518 impl NewWithNullPtr for wire_cst_prepare_receive_response {
12519 fn new_with_null_ptr() -> Self {
12520 Self {
12521 payment_method: Default::default(),
12522 amount: core::ptr::null_mut(),
12523 fees_sat: Default::default(),
12524 min_payer_amount_sat: core::ptr::null_mut(),
12525 max_payer_amount_sat: core::ptr::null_mut(),
12526 swapper_feerate: core::ptr::null_mut(),
12527 }
12528 }
12529 }
12530 impl Default for wire_cst_prepare_receive_response {
12531 fn default() -> Self {
12532 Self::new_with_null_ptr()
12533 }
12534 }
12535 impl NewWithNullPtr for wire_cst_prepare_refund_request {
12536 fn new_with_null_ptr() -> Self {
12537 Self {
12538 swap_address: core::ptr::null_mut(),
12539 refund_address: core::ptr::null_mut(),
12540 fee_rate_sat_per_vbyte: Default::default(),
12541 }
12542 }
12543 }
12544 impl Default for wire_cst_prepare_refund_request {
12545 fn default() -> Self {
12546 Self::new_with_null_ptr()
12547 }
12548 }
12549 impl NewWithNullPtr for wire_cst_prepare_refund_response {
12550 fn new_with_null_ptr() -> Self {
12551 Self {
12552 tx_vsize: Default::default(),
12553 tx_fee_sat: Default::default(),
12554 last_refund_tx_id: core::ptr::null_mut(),
12555 }
12556 }
12557 }
12558 impl Default for wire_cst_prepare_refund_response {
12559 fn default() -> Self {
12560 Self::new_with_null_ptr()
12561 }
12562 }
12563 impl NewWithNullPtr for wire_cst_prepare_send_request {
12564 fn new_with_null_ptr() -> Self {
12565 Self {
12566 destination: core::ptr::null_mut(),
12567 amount: core::ptr::null_mut(),
12568 }
12569 }
12570 }
12571 impl Default for wire_cst_prepare_send_request {
12572 fn default() -> Self {
12573 Self::new_with_null_ptr()
12574 }
12575 }
12576 impl NewWithNullPtr for wire_cst_prepare_send_response {
12577 fn new_with_null_ptr() -> Self {
12578 Self {
12579 destination: Default::default(),
12580 fees_sat: core::ptr::null_mut(),
12581 estimated_asset_fees: core::ptr::null_mut(),
12582 }
12583 }
12584 }
12585 impl Default for wire_cst_prepare_send_response {
12586 fn default() -> Self {
12587 Self::new_with_null_ptr()
12588 }
12589 }
12590 impl NewWithNullPtr for wire_cst_rate {
12591 fn new_with_null_ptr() -> Self {
12592 Self {
12593 coin: core::ptr::null_mut(),
12594 value: Default::default(),
12595 }
12596 }
12597 }
12598 impl Default for wire_cst_rate {
12599 fn default() -> Self {
12600 Self::new_with_null_ptr()
12601 }
12602 }
12603 impl NewWithNullPtr for wire_cst_receive_amount {
12604 fn new_with_null_ptr() -> Self {
12605 Self {
12606 tag: -1,
12607 kind: ReceiveAmountKind { nil__: () },
12608 }
12609 }
12610 }
12611 impl Default for wire_cst_receive_amount {
12612 fn default() -> Self {
12613 Self::new_with_null_ptr()
12614 }
12615 }
12616 impl NewWithNullPtr for wire_cst_receive_payment_request {
12617 fn new_with_null_ptr() -> Self {
12618 Self {
12619 prepare_response: Default::default(),
12620 description: core::ptr::null_mut(),
12621 use_description_hash: core::ptr::null_mut(),
12622 }
12623 }
12624 }
12625 impl Default for wire_cst_receive_payment_request {
12626 fn default() -> Self {
12627 Self::new_with_null_ptr()
12628 }
12629 }
12630 impl NewWithNullPtr for wire_cst_receive_payment_response {
12631 fn new_with_null_ptr() -> Self {
12632 Self {
12633 destination: core::ptr::null_mut(),
12634 }
12635 }
12636 }
12637 impl Default for wire_cst_receive_payment_response {
12638 fn default() -> Self {
12639 Self::new_with_null_ptr()
12640 }
12641 }
12642 impl NewWithNullPtr for wire_cst_recommended_fees {
12643 fn new_with_null_ptr() -> Self {
12644 Self {
12645 fastest_fee: Default::default(),
12646 half_hour_fee: Default::default(),
12647 hour_fee: Default::default(),
12648 economy_fee: Default::default(),
12649 minimum_fee: Default::default(),
12650 }
12651 }
12652 }
12653 impl Default for wire_cst_recommended_fees {
12654 fn default() -> Self {
12655 Self::new_with_null_ptr()
12656 }
12657 }
12658 impl NewWithNullPtr for wire_cst_refund_request {
12659 fn new_with_null_ptr() -> Self {
12660 Self {
12661 swap_address: core::ptr::null_mut(),
12662 refund_address: core::ptr::null_mut(),
12663 fee_rate_sat_per_vbyte: Default::default(),
12664 }
12665 }
12666 }
12667 impl Default for wire_cst_refund_request {
12668 fn default() -> Self {
12669 Self::new_with_null_ptr()
12670 }
12671 }
12672 impl NewWithNullPtr for wire_cst_refund_response {
12673 fn new_with_null_ptr() -> Self {
12674 Self {
12675 refund_tx_id: core::ptr::null_mut(),
12676 }
12677 }
12678 }
12679 impl Default for wire_cst_refund_response {
12680 fn default() -> Self {
12681 Self::new_with_null_ptr()
12682 }
12683 }
12684 impl NewWithNullPtr for wire_cst_refundable_swap {
12685 fn new_with_null_ptr() -> Self {
12686 Self {
12687 swap_address: core::ptr::null_mut(),
12688 timestamp: Default::default(),
12689 amount_sat: Default::default(),
12690 last_refund_tx_id: core::ptr::null_mut(),
12691 }
12692 }
12693 }
12694 impl Default for wire_cst_refundable_swap {
12695 fn default() -> Self {
12696 Self::new_with_null_ptr()
12697 }
12698 }
12699 impl NewWithNullPtr for wire_cst_restore_request {
12700 fn new_with_null_ptr() -> Self {
12701 Self {
12702 backup_path: core::ptr::null_mut(),
12703 }
12704 }
12705 }
12706 impl Default for wire_cst_restore_request {
12707 fn default() -> Self {
12708 Self::new_with_null_ptr()
12709 }
12710 }
12711 impl NewWithNullPtr for wire_cst_route_hint {
12712 fn new_with_null_ptr() -> Self {
12713 Self {
12714 hops: core::ptr::null_mut(),
12715 }
12716 }
12717 }
12718 impl Default for wire_cst_route_hint {
12719 fn default() -> Self {
12720 Self::new_with_null_ptr()
12721 }
12722 }
12723 impl NewWithNullPtr for wire_cst_route_hint_hop {
12724 fn new_with_null_ptr() -> Self {
12725 Self {
12726 src_node_id: core::ptr::null_mut(),
12727 short_channel_id: core::ptr::null_mut(),
12728 fees_base_msat: Default::default(),
12729 fees_proportional_millionths: Default::default(),
12730 cltv_expiry_delta: Default::default(),
12731 htlc_minimum_msat: core::ptr::null_mut(),
12732 htlc_maximum_msat: core::ptr::null_mut(),
12733 }
12734 }
12735 }
12736 impl Default for wire_cst_route_hint_hop {
12737 fn default() -> Self {
12738 Self::new_with_null_ptr()
12739 }
12740 }
12741 impl NewWithNullPtr for wire_cst_sdk_error {
12742 fn new_with_null_ptr() -> Self {
12743 Self {
12744 tag: -1,
12745 kind: SdkErrorKind { nil__: () },
12746 }
12747 }
12748 }
12749 impl Default for wire_cst_sdk_error {
12750 fn default() -> Self {
12751 Self::new_with_null_ptr()
12752 }
12753 }
12754 impl NewWithNullPtr for wire_cst_sdk_event {
12755 fn new_with_null_ptr() -> Self {
12756 Self {
12757 tag: -1,
12758 kind: SdkEventKind { nil__: () },
12759 }
12760 }
12761 }
12762 impl Default for wire_cst_sdk_event {
12763 fn default() -> Self {
12764 Self::new_with_null_ptr()
12765 }
12766 }
12767 impl NewWithNullPtr for wire_cst_send_destination {
12768 fn new_with_null_ptr() -> Self {
12769 Self {
12770 tag: -1,
12771 kind: SendDestinationKind { nil__: () },
12772 }
12773 }
12774 }
12775 impl Default for wire_cst_send_destination {
12776 fn default() -> Self {
12777 Self::new_with_null_ptr()
12778 }
12779 }
12780 impl NewWithNullPtr for wire_cst_send_payment_request {
12781 fn new_with_null_ptr() -> Self {
12782 Self {
12783 prepare_response: Default::default(),
12784 use_asset_fees: core::ptr::null_mut(),
12785 }
12786 }
12787 }
12788 impl Default for wire_cst_send_payment_request {
12789 fn default() -> Self {
12790 Self::new_with_null_ptr()
12791 }
12792 }
12793 impl NewWithNullPtr for wire_cst_send_payment_response {
12794 fn new_with_null_ptr() -> Self {
12795 Self {
12796 payment: Default::default(),
12797 }
12798 }
12799 }
12800 impl Default for wire_cst_send_payment_response {
12801 fn default() -> Self {
12802 Self::new_with_null_ptr()
12803 }
12804 }
12805 impl NewWithNullPtr for wire_cst_sign_message_request {
12806 fn new_with_null_ptr() -> Self {
12807 Self {
12808 message: core::ptr::null_mut(),
12809 }
12810 }
12811 }
12812 impl Default for wire_cst_sign_message_request {
12813 fn default() -> Self {
12814 Self::new_with_null_ptr()
12815 }
12816 }
12817 impl NewWithNullPtr for wire_cst_sign_message_response {
12818 fn new_with_null_ptr() -> Self {
12819 Self {
12820 signature: core::ptr::null_mut(),
12821 }
12822 }
12823 }
12824 impl Default for wire_cst_sign_message_response {
12825 fn default() -> Self {
12826 Self::new_with_null_ptr()
12827 }
12828 }
12829 impl NewWithNullPtr for wire_cst_success_action {
12830 fn new_with_null_ptr() -> Self {
12831 Self {
12832 tag: -1,
12833 kind: SuccessActionKind { nil__: () },
12834 }
12835 }
12836 }
12837 impl Default for wire_cst_success_action {
12838 fn default() -> Self {
12839 Self::new_with_null_ptr()
12840 }
12841 }
12842 impl NewWithNullPtr for wire_cst_success_action_processed {
12843 fn new_with_null_ptr() -> Self {
12844 Self {
12845 tag: -1,
12846 kind: SuccessActionProcessedKind { nil__: () },
12847 }
12848 }
12849 }
12850 impl Default for wire_cst_success_action_processed {
12851 fn default() -> Self {
12852 Self::new_with_null_ptr()
12853 }
12854 }
12855 impl NewWithNullPtr for wire_cst_symbol {
12856 fn new_with_null_ptr() -> Self {
12857 Self {
12858 grapheme: core::ptr::null_mut(),
12859 template: core::ptr::null_mut(),
12860 rtl: core::ptr::null_mut(),
12861 position: core::ptr::null_mut(),
12862 }
12863 }
12864 }
12865 impl Default for wire_cst_symbol {
12866 fn default() -> Self {
12867 Self::new_with_null_ptr()
12868 }
12869 }
12870 impl NewWithNullPtr for wire_cst_url_success_action_data {
12871 fn new_with_null_ptr() -> Self {
12872 Self {
12873 description: core::ptr::null_mut(),
12874 url: core::ptr::null_mut(),
12875 matches_callback_domain: Default::default(),
12876 }
12877 }
12878 }
12879 impl Default for wire_cst_url_success_action_data {
12880 fn default() -> Self {
12881 Self::new_with_null_ptr()
12882 }
12883 }
12884 impl NewWithNullPtr for wire_cst_wallet_info {
12885 fn new_with_null_ptr() -> Self {
12886 Self {
12887 balance_sat: Default::default(),
12888 pending_send_sat: Default::default(),
12889 pending_receive_sat: Default::default(),
12890 fingerprint: core::ptr::null_mut(),
12891 pubkey: core::ptr::null_mut(),
12892 asset_balances: core::ptr::null_mut(),
12893 }
12894 }
12895 }
12896 impl Default for wire_cst_wallet_info {
12897 fn default() -> Self {
12898 Self::new_with_null_ptr()
12899 }
12900 }
12901
12902 #[unsafe(no_mangle)]
12903 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees(
12904 port_: i64,
12905 that: usize,
12906 req: *mut wire_cst_accept_payment_proposed_fees_request,
12907 ) {
12908 wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(port_, that, req)
12909 }
12910
12911 #[unsafe(no_mangle)]
12912 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_add_event_listener(
12913 port_: i64,
12914 that: usize,
12915 listener: *mut wire_cst_list_prim_u_8_strict,
12916 ) {
12917 wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(port_, that, listener)
12918 }
12919
12920 #[unsafe(no_mangle)]
12921 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_backup(
12922 that: usize,
12923 req: *mut wire_cst_backup_request,
12924 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
12925 wire__crate__bindings__BindingLiquidSdk_backup_impl(that, req)
12926 }
12927
12928 #[unsafe(no_mangle)]
12929 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_buy_bitcoin(
12930 port_: i64,
12931 that: usize,
12932 req: *mut wire_cst_buy_bitcoin_request,
12933 ) {
12934 wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(port_, that, req)
12935 }
12936
12937 #[unsafe(no_mangle)]
12938 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_check_message(
12939 that: usize,
12940 req: *mut wire_cst_check_message_request,
12941 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
12942 wire__crate__bindings__BindingLiquidSdk_check_message_impl(that, req)
12943 }
12944
12945 #[unsafe(no_mangle)]
12946 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_disconnect(
12947 port_: i64,
12948 that: usize,
12949 ) {
12950 wire__crate__bindings__BindingLiquidSdk_disconnect_impl(port_, that)
12951 }
12952
12953 #[unsafe(no_mangle)]
12954 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache(
12955 that: usize,
12956 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
12957 wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(that)
12958 }
12959
12960 #[unsafe(no_mangle)]
12961 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates(
12962 port_: i64,
12963 that: usize,
12964 ) {
12965 wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(port_, that)
12966 }
12967
12968 #[unsafe(no_mangle)]
12969 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
12970 port_: i64,
12971 that: usize,
12972 ) {
12973 wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(port_, that)
12974 }
12975
12976 #[unsafe(no_mangle)]
12977 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
12978 port_: i64,
12979 that: usize,
12980 ) {
12981 wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(port_, that)
12982 }
12983
12984 #[unsafe(no_mangle)]
12985 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees(
12986 port_: i64,
12987 that: usize,
12988 req: *mut wire_cst_fetch_payment_proposed_fees_request,
12989 ) {
12990 wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(port_, that, req)
12991 }
12992
12993 #[unsafe(no_mangle)]
12994 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info(
12995 port_: i64,
12996 that: usize,
12997 ) {
12998 wire__crate__bindings__BindingLiquidSdk_get_info_impl(port_, that)
12999 }
13000
13001 #[unsafe(no_mangle)]
13002 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_payment(
13003 port_: i64,
13004 that: usize,
13005 req: *mut wire_cst_get_payment_request,
13006 ) {
13007 wire__crate__bindings__BindingLiquidSdk_get_payment_impl(port_, that, req)
13008 }
13009
13010 #[unsafe(no_mangle)]
13011 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies(
13012 port_: i64,
13013 that: usize,
13014 ) {
13015 wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(port_, that)
13016 }
13017
13018 #[unsafe(no_mangle)]
13019 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_payments(
13020 port_: i64,
13021 that: usize,
13022 req: *mut wire_cst_list_payments_request,
13023 ) {
13024 wire__crate__bindings__BindingLiquidSdk_list_payments_impl(port_, that, req)
13025 }
13026
13027 #[unsafe(no_mangle)]
13028 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_refundables(
13029 port_: i64,
13030 that: usize,
13031 ) {
13032 wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(port_, that)
13033 }
13034
13035 #[unsafe(no_mangle)]
13036 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_auth(
13037 port_: i64,
13038 that: usize,
13039 req_data: *mut wire_cst_ln_url_auth_request_data,
13040 ) {
13041 wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(port_, that, req_data)
13042 }
13043
13044 #[unsafe(no_mangle)]
13045 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_pay(
13046 port_: i64,
13047 that: usize,
13048 req: *mut wire_cst_ln_url_pay_request,
13049 ) {
13050 wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(port_, that, req)
13051 }
13052
13053 #[unsafe(no_mangle)]
13054 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw(
13055 port_: i64,
13056 that: usize,
13057 req: *mut wire_cst_ln_url_withdraw_request,
13058 ) {
13059 wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(port_, that, req)
13060 }
13061
13062 #[unsafe(no_mangle)]
13063 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_parse(
13064 port_: i64,
13065 that: usize,
13066 input: *mut wire_cst_list_prim_u_8_strict,
13067 ) {
13068 wire__crate__bindings__BindingLiquidSdk_parse_impl(port_, that, input)
13069 }
13070
13071 #[unsafe(no_mangle)]
13072 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_pay_onchain(
13073 port_: i64,
13074 that: usize,
13075 req: *mut wire_cst_pay_onchain_request,
13076 ) {
13077 wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(port_, that, req)
13078 }
13079
13080 #[unsafe(no_mangle)]
13081 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin(
13082 port_: i64,
13083 that: usize,
13084 req: *mut wire_cst_prepare_buy_bitcoin_request,
13085 ) {
13086 wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(port_, that, req)
13087 }
13088
13089 #[unsafe(no_mangle)]
13090 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay(
13091 port_: i64,
13092 that: usize,
13093 req: *mut wire_cst_prepare_ln_url_pay_request,
13094 ) {
13095 wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(port_, that, req)
13096 }
13097
13098 #[unsafe(no_mangle)]
13099 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain(
13100 port_: i64,
13101 that: usize,
13102 req: *mut wire_cst_prepare_pay_onchain_request,
13103 ) {
13104 wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(port_, that, req)
13105 }
13106
13107 #[unsafe(no_mangle)]
13108 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment(
13109 port_: i64,
13110 that: usize,
13111 req: *mut wire_cst_prepare_receive_request,
13112 ) {
13113 wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(port_, that, req)
13114 }
13115
13116 #[unsafe(no_mangle)]
13117 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_refund(
13118 port_: i64,
13119 that: usize,
13120 req: *mut wire_cst_prepare_refund_request,
13121 ) {
13122 wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(port_, that, req)
13123 }
13124
13125 #[unsafe(no_mangle)]
13126 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_send_payment(
13127 port_: i64,
13128 that: usize,
13129 req: *mut wire_cst_prepare_send_request,
13130 ) {
13131 wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(port_, that, req)
13132 }
13133
13134 #[unsafe(no_mangle)]
13135 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_receive_payment(
13136 port_: i64,
13137 that: usize,
13138 req: *mut wire_cst_receive_payment_request,
13139 ) {
13140 wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(port_, that, req)
13141 }
13142
13143 #[unsafe(no_mangle)]
13144 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_recommended_fees(
13145 port_: i64,
13146 that: usize,
13147 ) {
13148 wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(port_, that)
13149 }
13150
13151 #[unsafe(no_mangle)]
13152 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_refund(
13153 port_: i64,
13154 that: usize,
13155 req: *mut wire_cst_refund_request,
13156 ) {
13157 wire__crate__bindings__BindingLiquidSdk_refund_impl(port_, that, req)
13158 }
13159
13160 #[unsafe(no_mangle)]
13161 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_register_webhook(
13162 port_: i64,
13163 that: usize,
13164 webhook_url: *mut wire_cst_list_prim_u_8_strict,
13165 ) {
13166 wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(port_, that, webhook_url)
13167 }
13168
13169 #[unsafe(no_mangle)]
13170 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps(
13171 port_: i64,
13172 that: usize,
13173 ) {
13174 wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(port_, that)
13175 }
13176
13177 #[unsafe(no_mangle)]
13178 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_restore(
13179 that: usize,
13180 req: *mut wire_cst_restore_request,
13181 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13182 wire__crate__bindings__BindingLiquidSdk_restore_impl(that, req)
13183 }
13184
13185 #[unsafe(no_mangle)]
13186 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_send_payment(
13187 port_: i64,
13188 that: usize,
13189 req: *mut wire_cst_send_payment_request,
13190 ) {
13191 wire__crate__bindings__BindingLiquidSdk_send_payment_impl(port_, that, req)
13192 }
13193
13194 #[unsafe(no_mangle)]
13195 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sign_message(
13196 that: usize,
13197 req: *mut wire_cst_sign_message_request,
13198 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13199 wire__crate__bindings__BindingLiquidSdk_sign_message_impl(that, req)
13200 }
13201
13202 #[unsafe(no_mangle)]
13203 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sync(
13204 port_: i64,
13205 that: usize,
13206 ) {
13207 wire__crate__bindings__BindingLiquidSdk_sync_impl(port_, that)
13208 }
13209
13210 #[unsafe(no_mangle)]
13211 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_unregister_webhook(
13212 port_: i64,
13213 that: usize,
13214 ) {
13215 wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(port_, that)
13216 }
13217
13218 #[unsafe(no_mangle)]
13219 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__binding_event_listener_on_event(
13220 port_: i64,
13221 that: *mut wire_cst_binding_event_listener,
13222 e: *mut wire_cst_sdk_event,
13223 ) {
13224 wire__crate__bindings__binding_event_listener_on_event_impl(port_, that, e)
13225 }
13226
13227 #[unsafe(no_mangle)]
13228 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__breez_log_stream(
13229 port_: i64,
13230 s: *mut wire_cst_list_prim_u_8_strict,
13231 ) {
13232 wire__crate__bindings__breez_log_stream_impl(port_, s)
13233 }
13234
13235 #[unsafe(no_mangle)]
13236 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__connect(
13237 port_: i64,
13238 req: *mut wire_cst_connect_request,
13239 ) {
13240 wire__crate__bindings__connect_impl(port_, req)
13241 }
13242
13243 #[unsafe(no_mangle)]
13244 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__default_config(
13245 network: i32,
13246 breez_api_key: *mut wire_cst_list_prim_u_8_strict,
13247 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13248 wire__crate__bindings__default_config_impl(network, breez_api_key)
13249 }
13250
13251 #[unsafe(no_mangle)]
13252 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__parse_invoice(
13253 input: *mut wire_cst_list_prim_u_8_strict,
13254 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13255 wire__crate__bindings__parse_invoice_impl(input)
13256 }
13257
13258 #[unsafe(no_mangle)]
13259 pub extern "C" fn frbgen_breez_liquid_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13260 ptr: *const std::ffi::c_void,
13261 ) {
13262 unsafe {
13263 StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::increment_strong_count(ptr as _);
13264 }
13265 }
13266
13267 #[unsafe(no_mangle)]
13268 pub extern "C" fn frbgen_breez_liquid_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13269 ptr: *const std::ffi::c_void,
13270 ) {
13271 unsafe {
13272 StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::decrement_strong_count(ptr as _);
13273 }
13274 }
13275
13276 #[unsafe(no_mangle)]
13277 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_accept_payment_proposed_fees_request(
13278 ) -> *mut wire_cst_accept_payment_proposed_fees_request {
13279 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13280 wire_cst_accept_payment_proposed_fees_request::new_with_null_ptr(),
13281 )
13282 }
13283
13284 #[unsafe(no_mangle)]
13285 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data(
13286 ) -> *mut wire_cst_aes_success_action_data {
13287 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13288 wire_cst_aes_success_action_data::new_with_null_ptr(),
13289 )
13290 }
13291
13292 #[unsafe(no_mangle)]
13293 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_decrypted(
13294 ) -> *mut wire_cst_aes_success_action_data_decrypted {
13295 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13296 wire_cst_aes_success_action_data_decrypted::new_with_null_ptr(),
13297 )
13298 }
13299
13300 #[unsafe(no_mangle)]
13301 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_result(
13302 ) -> *mut wire_cst_aes_success_action_data_result {
13303 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13304 wire_cst_aes_success_action_data_result::new_with_null_ptr(),
13305 )
13306 }
13307
13308 #[unsafe(no_mangle)]
13309 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_amount() -> *mut wire_cst_amount {
13310 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_amount::new_with_null_ptr())
13311 }
13312
13313 #[unsafe(no_mangle)]
13314 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_asset_info(
13315 ) -> *mut wire_cst_asset_info {
13316 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13317 wire_cst_asset_info::new_with_null_ptr(),
13318 )
13319 }
13320
13321 #[unsafe(no_mangle)]
13322 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_backup_request(
13323 ) -> *mut wire_cst_backup_request {
13324 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13325 wire_cst_backup_request::new_with_null_ptr(),
13326 )
13327 }
13328
13329 #[unsafe(no_mangle)]
13330 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_binding_event_listener(
13331 ) -> *mut wire_cst_binding_event_listener {
13332 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13333 wire_cst_binding_event_listener::new_with_null_ptr(),
13334 )
13335 }
13336
13337 #[unsafe(no_mangle)]
13338 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bitcoin_address_data(
13339 ) -> *mut wire_cst_bitcoin_address_data {
13340 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13341 wire_cst_bitcoin_address_data::new_with_null_ptr(),
13342 )
13343 }
13344
13345 #[unsafe(no_mangle)]
13346 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bool(value: bool) -> *mut bool {
13347 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13348 }
13349
13350 #[unsafe(no_mangle)]
13351 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_buy_bitcoin_request(
13352 ) -> *mut wire_cst_buy_bitcoin_request {
13353 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13354 wire_cst_buy_bitcoin_request::new_with_null_ptr(),
13355 )
13356 }
13357
13358 #[unsafe(no_mangle)]
13359 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_check_message_request(
13360 ) -> *mut wire_cst_check_message_request {
13361 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13362 wire_cst_check_message_request::new_with_null_ptr(),
13363 )
13364 }
13365
13366 #[unsafe(no_mangle)]
13367 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_connect_request(
13368 ) -> *mut wire_cst_connect_request {
13369 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13370 wire_cst_connect_request::new_with_null_ptr(),
13371 )
13372 }
13373
13374 #[unsafe(no_mangle)]
13375 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_f_64(value: f64) -> *mut f64 {
13376 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13377 }
13378
13379 #[unsafe(no_mangle)]
13380 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_fetch_payment_proposed_fees_request(
13381 ) -> *mut wire_cst_fetch_payment_proposed_fees_request {
13382 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13383 wire_cst_fetch_payment_proposed_fees_request::new_with_null_ptr(),
13384 )
13385 }
13386
13387 #[unsafe(no_mangle)]
13388 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_get_payment_request(
13389 ) -> *mut wire_cst_get_payment_request {
13390 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13391 wire_cst_get_payment_request::new_with_null_ptr(),
13392 )
13393 }
13394
13395 #[unsafe(no_mangle)]
13396 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_i_64(value: i64) -> *mut i64 {
13397 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13398 }
13399
13400 #[unsafe(no_mangle)]
13401 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_liquid_address_data(
13402 ) -> *mut wire_cst_liquid_address_data {
13403 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13404 wire_cst_liquid_address_data::new_with_null_ptr(),
13405 )
13406 }
13407
13408 #[unsafe(no_mangle)]
13409 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payment_details(
13410 ) -> *mut wire_cst_list_payment_details {
13411 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13412 wire_cst_list_payment_details::new_with_null_ptr(),
13413 )
13414 }
13415
13416 #[unsafe(no_mangle)]
13417 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payments_request(
13418 ) -> *mut wire_cst_list_payments_request {
13419 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13420 wire_cst_list_payments_request::new_with_null_ptr(),
13421 )
13422 }
13423
13424 #[unsafe(no_mangle)]
13425 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_invoice(
13426 ) -> *mut wire_cst_ln_invoice {
13427 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13428 wire_cst_ln_invoice::new_with_null_ptr(),
13429 )
13430 }
13431
13432 #[unsafe(no_mangle)]
13433 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_offer() -> *mut wire_cst_ln_offer {
13434 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_ln_offer::new_with_null_ptr())
13435 }
13436
13437 #[unsafe(no_mangle)]
13438 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_auth_request_data(
13439 ) -> *mut wire_cst_ln_url_auth_request_data {
13440 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13441 wire_cst_ln_url_auth_request_data::new_with_null_ptr(),
13442 )
13443 }
13444
13445 #[unsafe(no_mangle)]
13446 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_error_data(
13447 ) -> *mut wire_cst_ln_url_error_data {
13448 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13449 wire_cst_ln_url_error_data::new_with_null_ptr(),
13450 )
13451 }
13452
13453 #[unsafe(no_mangle)]
13454 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_info(
13455 ) -> *mut wire_cst_ln_url_info {
13456 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13457 wire_cst_ln_url_info::new_with_null_ptr(),
13458 )
13459 }
13460
13461 #[unsafe(no_mangle)]
13462 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_error_data(
13463 ) -> *mut wire_cst_ln_url_pay_error_data {
13464 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13465 wire_cst_ln_url_pay_error_data::new_with_null_ptr(),
13466 )
13467 }
13468
13469 #[unsafe(no_mangle)]
13470 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request(
13471 ) -> *mut wire_cst_ln_url_pay_request {
13472 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13473 wire_cst_ln_url_pay_request::new_with_null_ptr(),
13474 )
13475 }
13476
13477 #[unsafe(no_mangle)]
13478 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request_data(
13479 ) -> *mut wire_cst_ln_url_pay_request_data {
13480 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13481 wire_cst_ln_url_pay_request_data::new_with_null_ptr(),
13482 )
13483 }
13484
13485 #[unsafe(no_mangle)]
13486 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_success_data(
13487 ) -> *mut wire_cst_ln_url_pay_success_data {
13488 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13489 wire_cst_ln_url_pay_success_data::new_with_null_ptr(),
13490 )
13491 }
13492
13493 #[unsafe(no_mangle)]
13494 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request(
13495 ) -> *mut wire_cst_ln_url_withdraw_request {
13496 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13497 wire_cst_ln_url_withdraw_request::new_with_null_ptr(),
13498 )
13499 }
13500
13501 #[unsafe(no_mangle)]
13502 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request_data(
13503 ) -> *mut wire_cst_ln_url_withdraw_request_data {
13504 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13505 wire_cst_ln_url_withdraw_request_data::new_with_null_ptr(),
13506 )
13507 }
13508
13509 #[unsafe(no_mangle)]
13510 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_success_data(
13511 ) -> *mut wire_cst_ln_url_withdraw_success_data {
13512 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13513 wire_cst_ln_url_withdraw_success_data::new_with_null_ptr(),
13514 )
13515 }
13516
13517 #[unsafe(no_mangle)]
13518 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_message_success_action_data(
13519 ) -> *mut wire_cst_message_success_action_data {
13520 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13521 wire_cst_message_success_action_data::new_with_null_ptr(),
13522 )
13523 }
13524
13525 #[unsafe(no_mangle)]
13526 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_amount(
13527 ) -> *mut wire_cst_pay_amount {
13528 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13529 wire_cst_pay_amount::new_with_null_ptr(),
13530 )
13531 }
13532
13533 #[unsafe(no_mangle)]
13534 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_onchain_request(
13535 ) -> *mut wire_cst_pay_onchain_request {
13536 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13537 wire_cst_pay_onchain_request::new_with_null_ptr(),
13538 )
13539 }
13540
13541 #[unsafe(no_mangle)]
13542 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_payment() -> *mut wire_cst_payment {
13543 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_payment::new_with_null_ptr())
13544 }
13545
13546 #[unsafe(no_mangle)]
13547 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_buy_bitcoin_request(
13548 ) -> *mut wire_cst_prepare_buy_bitcoin_request {
13549 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13550 wire_cst_prepare_buy_bitcoin_request::new_with_null_ptr(),
13551 )
13552 }
13553
13554 #[unsafe(no_mangle)]
13555 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_ln_url_pay_request(
13556 ) -> *mut wire_cst_prepare_ln_url_pay_request {
13557 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13558 wire_cst_prepare_ln_url_pay_request::new_with_null_ptr(),
13559 )
13560 }
13561
13562 #[unsafe(no_mangle)]
13563 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_pay_onchain_request(
13564 ) -> *mut wire_cst_prepare_pay_onchain_request {
13565 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13566 wire_cst_prepare_pay_onchain_request::new_with_null_ptr(),
13567 )
13568 }
13569
13570 #[unsafe(no_mangle)]
13571 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_receive_request(
13572 ) -> *mut wire_cst_prepare_receive_request {
13573 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13574 wire_cst_prepare_receive_request::new_with_null_ptr(),
13575 )
13576 }
13577
13578 #[unsafe(no_mangle)]
13579 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_refund_request(
13580 ) -> *mut wire_cst_prepare_refund_request {
13581 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13582 wire_cst_prepare_refund_request::new_with_null_ptr(),
13583 )
13584 }
13585
13586 #[unsafe(no_mangle)]
13587 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_send_request(
13588 ) -> *mut wire_cst_prepare_send_request {
13589 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13590 wire_cst_prepare_send_request::new_with_null_ptr(),
13591 )
13592 }
13593
13594 #[unsafe(no_mangle)]
13595 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_amount(
13596 ) -> *mut wire_cst_receive_amount {
13597 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13598 wire_cst_receive_amount::new_with_null_ptr(),
13599 )
13600 }
13601
13602 #[unsafe(no_mangle)]
13603 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_payment_request(
13604 ) -> *mut wire_cst_receive_payment_request {
13605 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13606 wire_cst_receive_payment_request::new_with_null_ptr(),
13607 )
13608 }
13609
13610 #[unsafe(no_mangle)]
13611 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_refund_request(
13612 ) -> *mut wire_cst_refund_request {
13613 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13614 wire_cst_refund_request::new_with_null_ptr(),
13615 )
13616 }
13617
13618 #[unsafe(no_mangle)]
13619 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_restore_request(
13620 ) -> *mut wire_cst_restore_request {
13621 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13622 wire_cst_restore_request::new_with_null_ptr(),
13623 )
13624 }
13625
13626 #[unsafe(no_mangle)]
13627 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sdk_event() -> *mut wire_cst_sdk_event
13628 {
13629 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_sdk_event::new_with_null_ptr())
13630 }
13631
13632 #[unsafe(no_mangle)]
13633 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_send_payment_request(
13634 ) -> *mut wire_cst_send_payment_request {
13635 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13636 wire_cst_send_payment_request::new_with_null_ptr(),
13637 )
13638 }
13639
13640 #[unsafe(no_mangle)]
13641 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sign_message_request(
13642 ) -> *mut wire_cst_sign_message_request {
13643 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13644 wire_cst_sign_message_request::new_with_null_ptr(),
13645 )
13646 }
13647
13648 #[unsafe(no_mangle)]
13649 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action(
13650 ) -> *mut wire_cst_success_action {
13651 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13652 wire_cst_success_action::new_with_null_ptr(),
13653 )
13654 }
13655
13656 #[unsafe(no_mangle)]
13657 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action_processed(
13658 ) -> *mut wire_cst_success_action_processed {
13659 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13660 wire_cst_success_action_processed::new_with_null_ptr(),
13661 )
13662 }
13663
13664 #[unsafe(no_mangle)]
13665 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_symbol() -> *mut wire_cst_symbol {
13666 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_symbol::new_with_null_ptr())
13667 }
13668
13669 #[unsafe(no_mangle)]
13670 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_32(value: u32) -> *mut u32 {
13671 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13672 }
13673
13674 #[unsafe(no_mangle)]
13675 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_64(value: u64) -> *mut u64 {
13676 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13677 }
13678
13679 #[unsafe(no_mangle)]
13680 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_url_success_action_data(
13681 ) -> *mut wire_cst_url_success_action_data {
13682 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13683 wire_cst_url_success_action_data::new_with_null_ptr(),
13684 )
13685 }
13686
13687 #[unsafe(no_mangle)]
13688 pub extern "C" fn frbgen_breez_liquid_cst_new_list_String(
13689 len: i32,
13690 ) -> *mut wire_cst_list_String {
13691 let wrap = wire_cst_list_String {
13692 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13693 <*mut wire_cst_list_prim_u_8_strict>::new_with_null_ptr(),
13694 len,
13695 ),
13696 len,
13697 };
13698 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13699 }
13700
13701 #[unsafe(no_mangle)]
13702 pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_balance(
13703 len: i32,
13704 ) -> *mut wire_cst_list_asset_balance {
13705 let wrap = wire_cst_list_asset_balance {
13706 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13707 <wire_cst_asset_balance>::new_with_null_ptr(),
13708 len,
13709 ),
13710 len,
13711 };
13712 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13713 }
13714
13715 #[unsafe(no_mangle)]
13716 pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_metadata(
13717 len: i32,
13718 ) -> *mut wire_cst_list_asset_metadata {
13719 let wrap = wire_cst_list_asset_metadata {
13720 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13721 <wire_cst_asset_metadata>::new_with_null_ptr(),
13722 len,
13723 ),
13724 len,
13725 };
13726 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13727 }
13728
13729 #[unsafe(no_mangle)]
13730 pub extern "C" fn frbgen_breez_liquid_cst_new_list_external_input_parser(
13731 len: i32,
13732 ) -> *mut wire_cst_list_external_input_parser {
13733 let wrap = wire_cst_list_external_input_parser {
13734 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13735 <wire_cst_external_input_parser>::new_with_null_ptr(),
13736 len,
13737 ),
13738 len,
13739 };
13740 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13741 }
13742
13743 #[unsafe(no_mangle)]
13744 pub extern "C" fn frbgen_breez_liquid_cst_new_list_fiat_currency(
13745 len: i32,
13746 ) -> *mut wire_cst_list_fiat_currency {
13747 let wrap = wire_cst_list_fiat_currency {
13748 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13749 <wire_cst_fiat_currency>::new_with_null_ptr(),
13750 len,
13751 ),
13752 len,
13753 };
13754 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13755 }
13756
13757 #[unsafe(no_mangle)]
13758 pub extern "C" fn frbgen_breez_liquid_cst_new_list_ln_offer_blinded_path(
13759 len: i32,
13760 ) -> *mut wire_cst_list_ln_offer_blinded_path {
13761 let wrap = wire_cst_list_ln_offer_blinded_path {
13762 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13763 <wire_cst_ln_offer_blinded_path>::new_with_null_ptr(),
13764 len,
13765 ),
13766 len,
13767 };
13768 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13769 }
13770
13771 #[unsafe(no_mangle)]
13772 pub extern "C" fn frbgen_breez_liquid_cst_new_list_locale_overrides(
13773 len: i32,
13774 ) -> *mut wire_cst_list_locale_overrides {
13775 let wrap = wire_cst_list_locale_overrides {
13776 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13777 <wire_cst_locale_overrides>::new_with_null_ptr(),
13778 len,
13779 ),
13780 len,
13781 };
13782 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13783 }
13784
13785 #[unsafe(no_mangle)]
13786 pub extern "C" fn frbgen_breez_liquid_cst_new_list_localized_name(
13787 len: i32,
13788 ) -> *mut wire_cst_list_localized_name {
13789 let wrap = wire_cst_list_localized_name {
13790 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13791 <wire_cst_localized_name>::new_with_null_ptr(),
13792 len,
13793 ),
13794 len,
13795 };
13796 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13797 }
13798
13799 #[unsafe(no_mangle)]
13800 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment(
13801 len: i32,
13802 ) -> *mut wire_cst_list_payment {
13803 let wrap = wire_cst_list_payment {
13804 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13805 <wire_cst_payment>::new_with_null_ptr(),
13806 len,
13807 ),
13808 len,
13809 };
13810 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13811 }
13812
13813 #[unsafe(no_mangle)]
13814 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_state(
13815 len: i32,
13816 ) -> *mut wire_cst_list_payment_state {
13817 let wrap = wire_cst_list_payment_state {
13818 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
13819 len,
13820 };
13821 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13822 }
13823
13824 #[unsafe(no_mangle)]
13825 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_type(
13826 len: i32,
13827 ) -> *mut wire_cst_list_payment_type {
13828 let wrap = wire_cst_list_payment_type {
13829 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
13830 len,
13831 };
13832 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13833 }
13834
13835 #[unsafe(no_mangle)]
13836 pub extern "C" fn frbgen_breez_liquid_cst_new_list_prim_u_8_strict(
13837 len: i32,
13838 ) -> *mut wire_cst_list_prim_u_8_strict {
13839 let ans = wire_cst_list_prim_u_8_strict {
13840 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
13841 len,
13842 };
13843 flutter_rust_bridge::for_generated::new_leak_box_ptr(ans)
13844 }
13845
13846 #[unsafe(no_mangle)]
13847 pub extern "C" fn frbgen_breez_liquid_cst_new_list_rate(len: i32) -> *mut wire_cst_list_rate {
13848 let wrap = wire_cst_list_rate {
13849 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13850 <wire_cst_rate>::new_with_null_ptr(),
13851 len,
13852 ),
13853 len,
13854 };
13855 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13856 }
13857
13858 #[unsafe(no_mangle)]
13859 pub extern "C" fn frbgen_breez_liquid_cst_new_list_refundable_swap(
13860 len: i32,
13861 ) -> *mut wire_cst_list_refundable_swap {
13862 let wrap = wire_cst_list_refundable_swap {
13863 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13864 <wire_cst_refundable_swap>::new_with_null_ptr(),
13865 len,
13866 ),
13867 len,
13868 };
13869 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13870 }
13871
13872 #[unsafe(no_mangle)]
13873 pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint(
13874 len: i32,
13875 ) -> *mut wire_cst_list_route_hint {
13876 let wrap = wire_cst_list_route_hint {
13877 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13878 <wire_cst_route_hint>::new_with_null_ptr(),
13879 len,
13880 ),
13881 len,
13882 };
13883 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13884 }
13885
13886 #[unsafe(no_mangle)]
13887 pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint_hop(
13888 len: i32,
13889 ) -> *mut wire_cst_list_route_hint_hop {
13890 let wrap = wire_cst_list_route_hint_hop {
13891 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13892 <wire_cst_route_hint_hop>::new_with_null_ptr(),
13893 len,
13894 ),
13895 len,
13896 };
13897 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13898 }
13899
13900 #[repr(C)]
13901 #[derive(Clone, Copy)]
13902 pub struct wire_cst_accept_payment_proposed_fees_request {
13903 response: wire_cst_fetch_payment_proposed_fees_response,
13904 }
13905 #[repr(C)]
13906 #[derive(Clone, Copy)]
13907 pub struct wire_cst_aes_success_action_data {
13908 description: *mut wire_cst_list_prim_u_8_strict,
13909 ciphertext: *mut wire_cst_list_prim_u_8_strict,
13910 iv: *mut wire_cst_list_prim_u_8_strict,
13911 }
13912 #[repr(C)]
13913 #[derive(Clone, Copy)]
13914 pub struct wire_cst_aes_success_action_data_decrypted {
13915 description: *mut wire_cst_list_prim_u_8_strict,
13916 plaintext: *mut wire_cst_list_prim_u_8_strict,
13917 }
13918 #[repr(C)]
13919 #[derive(Clone, Copy)]
13920 pub struct wire_cst_aes_success_action_data_result {
13921 tag: i32,
13922 kind: AesSuccessActionDataResultKind,
13923 }
13924 #[repr(C)]
13925 #[derive(Clone, Copy)]
13926 pub union AesSuccessActionDataResultKind {
13927 Decrypted: wire_cst_AesSuccessActionDataResult_Decrypted,
13928 ErrorStatus: wire_cst_AesSuccessActionDataResult_ErrorStatus,
13929 nil__: (),
13930 }
13931 #[repr(C)]
13932 #[derive(Clone, Copy)]
13933 pub struct wire_cst_AesSuccessActionDataResult_Decrypted {
13934 data: *mut wire_cst_aes_success_action_data_decrypted,
13935 }
13936 #[repr(C)]
13937 #[derive(Clone, Copy)]
13938 pub struct wire_cst_AesSuccessActionDataResult_ErrorStatus {
13939 reason: *mut wire_cst_list_prim_u_8_strict,
13940 }
13941 #[repr(C)]
13942 #[derive(Clone, Copy)]
13943 pub struct wire_cst_amount {
13944 tag: i32,
13945 kind: AmountKind,
13946 }
13947 #[repr(C)]
13948 #[derive(Clone, Copy)]
13949 pub union AmountKind {
13950 Bitcoin: wire_cst_Amount_Bitcoin,
13951 Currency: wire_cst_Amount_Currency,
13952 nil__: (),
13953 }
13954 #[repr(C)]
13955 #[derive(Clone, Copy)]
13956 pub struct wire_cst_Amount_Bitcoin {
13957 amount_msat: u64,
13958 }
13959 #[repr(C)]
13960 #[derive(Clone, Copy)]
13961 pub struct wire_cst_Amount_Currency {
13962 iso4217_code: *mut wire_cst_list_prim_u_8_strict,
13963 fractional_amount: u64,
13964 }
13965 #[repr(C)]
13966 #[derive(Clone, Copy)]
13967 pub struct wire_cst_asset_balance {
13968 asset_id: *mut wire_cst_list_prim_u_8_strict,
13969 balance_sat: u64,
13970 name: *mut wire_cst_list_prim_u_8_strict,
13971 ticker: *mut wire_cst_list_prim_u_8_strict,
13972 balance: *mut f64,
13973 }
13974 #[repr(C)]
13975 #[derive(Clone, Copy)]
13976 pub struct wire_cst_asset_info {
13977 name: *mut wire_cst_list_prim_u_8_strict,
13978 ticker: *mut wire_cst_list_prim_u_8_strict,
13979 amount: f64,
13980 fees: *mut f64,
13981 }
13982 #[repr(C)]
13983 #[derive(Clone, Copy)]
13984 pub struct wire_cst_asset_metadata {
13985 asset_id: *mut wire_cst_list_prim_u_8_strict,
13986 name: *mut wire_cst_list_prim_u_8_strict,
13987 ticker: *mut wire_cst_list_prim_u_8_strict,
13988 precision: u8,
13989 fiat_id: *mut wire_cst_list_prim_u_8_strict,
13990 }
13991 #[repr(C)]
13992 #[derive(Clone, Copy)]
13993 pub struct wire_cst_backup_request {
13994 backup_path: *mut wire_cst_list_prim_u_8_strict,
13995 }
13996 #[repr(C)]
13997 #[derive(Clone, Copy)]
13998 pub struct wire_cst_binding_event_listener {
13999 stream: *mut wire_cst_list_prim_u_8_strict,
14000 }
14001 #[repr(C)]
14002 #[derive(Clone, Copy)]
14003 pub struct wire_cst_bitcoin_address_data {
14004 address: *mut wire_cst_list_prim_u_8_strict,
14005 network: i32,
14006 amount_sat: *mut u64,
14007 label: *mut wire_cst_list_prim_u_8_strict,
14008 message: *mut wire_cst_list_prim_u_8_strict,
14009 }
14010 #[repr(C)]
14011 #[derive(Clone, Copy)]
14012 pub struct wire_cst_blockchain_explorer {
14013 tag: i32,
14014 kind: BlockchainExplorerKind,
14015 }
14016 #[repr(C)]
14017 #[derive(Clone, Copy)]
14018 pub union BlockchainExplorerKind {
14019 Electrum: wire_cst_BlockchainExplorer_Electrum,
14020 Esplora: wire_cst_BlockchainExplorer_Esplora,
14021 nil__: (),
14022 }
14023 #[repr(C)]
14024 #[derive(Clone, Copy)]
14025 pub struct wire_cst_BlockchainExplorer_Electrum {
14026 url: *mut wire_cst_list_prim_u_8_strict,
14027 }
14028 #[repr(C)]
14029 #[derive(Clone, Copy)]
14030 pub struct wire_cst_BlockchainExplorer_Esplora {
14031 url: *mut wire_cst_list_prim_u_8_strict,
14032 use_waterfalls: bool,
14033 }
14034 #[repr(C)]
14035 #[derive(Clone, Copy)]
14036 pub struct wire_cst_blockchain_info {
14037 liquid_tip: u32,
14038 bitcoin_tip: u32,
14039 }
14040 #[repr(C)]
14041 #[derive(Clone, Copy)]
14042 pub struct wire_cst_buy_bitcoin_request {
14043 prepare_response: wire_cst_prepare_buy_bitcoin_response,
14044 redirect_url: *mut wire_cst_list_prim_u_8_strict,
14045 }
14046 #[repr(C)]
14047 #[derive(Clone, Copy)]
14048 pub struct wire_cst_check_message_request {
14049 message: *mut wire_cst_list_prim_u_8_strict,
14050 pubkey: *mut wire_cst_list_prim_u_8_strict,
14051 signature: *mut wire_cst_list_prim_u_8_strict,
14052 }
14053 #[repr(C)]
14054 #[derive(Clone, Copy)]
14055 pub struct wire_cst_check_message_response {
14056 is_valid: bool,
14057 }
14058 #[repr(C)]
14059 #[derive(Clone, Copy)]
14060 pub struct wire_cst_config {
14061 liquid_explorer: wire_cst_blockchain_explorer,
14062 bitcoin_explorer: wire_cst_blockchain_explorer,
14063 working_dir: *mut wire_cst_list_prim_u_8_strict,
14064 cache_dir: *mut wire_cst_list_prim_u_8_strict,
14065 network: i32,
14066 payment_timeout_sec: u64,
14067 sync_service_url: *mut wire_cst_list_prim_u_8_strict,
14068 zero_conf_max_amount_sat: *mut u64,
14069 breez_api_key: *mut wire_cst_list_prim_u_8_strict,
14070 external_input_parsers: *mut wire_cst_list_external_input_parser,
14071 use_default_external_input_parsers: bool,
14072 onchain_fee_rate_leeway_sat_per_vbyte: *mut u32,
14073 asset_metadata: *mut wire_cst_list_asset_metadata,
14074 sideswap_api_key: *mut wire_cst_list_prim_u_8_strict,
14075 }
14076 #[repr(C)]
14077 #[derive(Clone, Copy)]
14078 pub struct wire_cst_connect_request {
14079 config: wire_cst_config,
14080 mnemonic: *mut wire_cst_list_prim_u_8_strict,
14081 passphrase: *mut wire_cst_list_prim_u_8_strict,
14082 seed: *mut wire_cst_list_prim_u_8_strict,
14083 }
14084 #[repr(C)]
14085 #[derive(Clone, Copy)]
14086 pub struct wire_cst_currency_info {
14087 name: *mut wire_cst_list_prim_u_8_strict,
14088 fraction_size: u32,
14089 spacing: *mut u32,
14090 symbol: *mut wire_cst_symbol,
14091 uniq_symbol: *mut wire_cst_symbol,
14092 localized_name: *mut wire_cst_list_localized_name,
14093 locale_overrides: *mut wire_cst_list_locale_overrides,
14094 }
14095 #[repr(C)]
14096 #[derive(Clone, Copy)]
14097 pub struct wire_cst_external_input_parser {
14098 provider_id: *mut wire_cst_list_prim_u_8_strict,
14099 input_regex: *mut wire_cst_list_prim_u_8_strict,
14100 parser_url: *mut wire_cst_list_prim_u_8_strict,
14101 }
14102 #[repr(C)]
14103 #[derive(Clone, Copy)]
14104 pub struct wire_cst_fetch_payment_proposed_fees_request {
14105 swap_id: *mut wire_cst_list_prim_u_8_strict,
14106 }
14107 #[repr(C)]
14108 #[derive(Clone, Copy)]
14109 pub struct wire_cst_fetch_payment_proposed_fees_response {
14110 swap_id: *mut wire_cst_list_prim_u_8_strict,
14111 fees_sat: u64,
14112 payer_amount_sat: u64,
14113 receiver_amount_sat: u64,
14114 }
14115 #[repr(C)]
14116 #[derive(Clone, Copy)]
14117 pub struct wire_cst_fiat_currency {
14118 id: *mut wire_cst_list_prim_u_8_strict,
14119 info: wire_cst_currency_info,
14120 }
14121 #[repr(C)]
14122 #[derive(Clone, Copy)]
14123 pub struct wire_cst_get_info_response {
14124 wallet_info: wire_cst_wallet_info,
14125 blockchain_info: wire_cst_blockchain_info,
14126 }
14127 #[repr(C)]
14128 #[derive(Clone, Copy)]
14129 pub struct wire_cst_get_payment_request {
14130 tag: i32,
14131 kind: GetPaymentRequestKind,
14132 }
14133 #[repr(C)]
14134 #[derive(Clone, Copy)]
14135 pub union GetPaymentRequestKind {
14136 PaymentHash: wire_cst_GetPaymentRequest_PaymentHash,
14137 SwapId: wire_cst_GetPaymentRequest_SwapId,
14138 nil__: (),
14139 }
14140 #[repr(C)]
14141 #[derive(Clone, Copy)]
14142 pub struct wire_cst_GetPaymentRequest_PaymentHash {
14143 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14144 }
14145 #[repr(C)]
14146 #[derive(Clone, Copy)]
14147 pub struct wire_cst_GetPaymentRequest_SwapId {
14148 swap_id: *mut wire_cst_list_prim_u_8_strict,
14149 }
14150 #[repr(C)]
14151 #[derive(Clone, Copy)]
14152 pub struct wire_cst_input_type {
14153 tag: i32,
14154 kind: InputTypeKind,
14155 }
14156 #[repr(C)]
14157 #[derive(Clone, Copy)]
14158 pub union InputTypeKind {
14159 BitcoinAddress: wire_cst_InputType_BitcoinAddress,
14160 LiquidAddress: wire_cst_InputType_LiquidAddress,
14161 Bolt11: wire_cst_InputType_Bolt11,
14162 Bolt12Offer: wire_cst_InputType_Bolt12Offer,
14163 NodeId: wire_cst_InputType_NodeId,
14164 Url: wire_cst_InputType_Url,
14165 LnUrlPay: wire_cst_InputType_LnUrlPay,
14166 LnUrlWithdraw: wire_cst_InputType_LnUrlWithdraw,
14167 LnUrlAuth: wire_cst_InputType_LnUrlAuth,
14168 LnUrlError: wire_cst_InputType_LnUrlError,
14169 nil__: (),
14170 }
14171 #[repr(C)]
14172 #[derive(Clone, Copy)]
14173 pub struct wire_cst_InputType_BitcoinAddress {
14174 address: *mut wire_cst_bitcoin_address_data,
14175 }
14176 #[repr(C)]
14177 #[derive(Clone, Copy)]
14178 pub struct wire_cst_InputType_LiquidAddress {
14179 address: *mut wire_cst_liquid_address_data,
14180 }
14181 #[repr(C)]
14182 #[derive(Clone, Copy)]
14183 pub struct wire_cst_InputType_Bolt11 {
14184 invoice: *mut wire_cst_ln_invoice,
14185 }
14186 #[repr(C)]
14187 #[derive(Clone, Copy)]
14188 pub struct wire_cst_InputType_Bolt12Offer {
14189 offer: *mut wire_cst_ln_offer,
14190 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14191 }
14192 #[repr(C)]
14193 #[derive(Clone, Copy)]
14194 pub struct wire_cst_InputType_NodeId {
14195 node_id: *mut wire_cst_list_prim_u_8_strict,
14196 }
14197 #[repr(C)]
14198 #[derive(Clone, Copy)]
14199 pub struct wire_cst_InputType_Url {
14200 url: *mut wire_cst_list_prim_u_8_strict,
14201 }
14202 #[repr(C)]
14203 #[derive(Clone, Copy)]
14204 pub struct wire_cst_InputType_LnUrlPay {
14205 data: *mut wire_cst_ln_url_pay_request_data,
14206 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14207 }
14208 #[repr(C)]
14209 #[derive(Clone, Copy)]
14210 pub struct wire_cst_InputType_LnUrlWithdraw {
14211 data: *mut wire_cst_ln_url_withdraw_request_data,
14212 }
14213 #[repr(C)]
14214 #[derive(Clone, Copy)]
14215 pub struct wire_cst_InputType_LnUrlAuth {
14216 data: *mut wire_cst_ln_url_auth_request_data,
14217 }
14218 #[repr(C)]
14219 #[derive(Clone, Copy)]
14220 pub struct wire_cst_InputType_LnUrlError {
14221 data: *mut wire_cst_ln_url_error_data,
14222 }
14223 #[repr(C)]
14224 #[derive(Clone, Copy)]
14225 pub struct wire_cst_lightning_payment_limits_response {
14226 send: wire_cst_limits,
14227 receive: wire_cst_limits,
14228 }
14229 #[repr(C)]
14230 #[derive(Clone, Copy)]
14231 pub struct wire_cst_limits {
14232 min_sat: u64,
14233 max_sat: u64,
14234 max_zero_conf_sat: u64,
14235 }
14236 #[repr(C)]
14237 #[derive(Clone, Copy)]
14238 pub struct wire_cst_liquid_address_data {
14239 address: *mut wire_cst_list_prim_u_8_strict,
14240 network: i32,
14241 asset_id: *mut wire_cst_list_prim_u_8_strict,
14242 amount: *mut f64,
14243 amount_sat: *mut u64,
14244 label: *mut wire_cst_list_prim_u_8_strict,
14245 message: *mut wire_cst_list_prim_u_8_strict,
14246 }
14247 #[repr(C)]
14248 #[derive(Clone, Copy)]
14249 pub struct wire_cst_list_String {
14250 ptr: *mut *mut wire_cst_list_prim_u_8_strict,
14251 len: i32,
14252 }
14253 #[repr(C)]
14254 #[derive(Clone, Copy)]
14255 pub struct wire_cst_list_asset_balance {
14256 ptr: *mut wire_cst_asset_balance,
14257 len: i32,
14258 }
14259 #[repr(C)]
14260 #[derive(Clone, Copy)]
14261 pub struct wire_cst_list_asset_metadata {
14262 ptr: *mut wire_cst_asset_metadata,
14263 len: i32,
14264 }
14265 #[repr(C)]
14266 #[derive(Clone, Copy)]
14267 pub struct wire_cst_list_external_input_parser {
14268 ptr: *mut wire_cst_external_input_parser,
14269 len: i32,
14270 }
14271 #[repr(C)]
14272 #[derive(Clone, Copy)]
14273 pub struct wire_cst_list_fiat_currency {
14274 ptr: *mut wire_cst_fiat_currency,
14275 len: i32,
14276 }
14277 #[repr(C)]
14278 #[derive(Clone, Copy)]
14279 pub struct wire_cst_list_ln_offer_blinded_path {
14280 ptr: *mut wire_cst_ln_offer_blinded_path,
14281 len: i32,
14282 }
14283 #[repr(C)]
14284 #[derive(Clone, Copy)]
14285 pub struct wire_cst_list_locale_overrides {
14286 ptr: *mut wire_cst_locale_overrides,
14287 len: i32,
14288 }
14289 #[repr(C)]
14290 #[derive(Clone, Copy)]
14291 pub struct wire_cst_list_localized_name {
14292 ptr: *mut wire_cst_localized_name,
14293 len: i32,
14294 }
14295 #[repr(C)]
14296 #[derive(Clone, Copy)]
14297 pub struct wire_cst_list_payment {
14298 ptr: *mut wire_cst_payment,
14299 len: i32,
14300 }
14301 #[repr(C)]
14302 #[derive(Clone, Copy)]
14303 pub struct wire_cst_list_payment_details {
14304 tag: i32,
14305 kind: ListPaymentDetailsKind,
14306 }
14307 #[repr(C)]
14308 #[derive(Clone, Copy)]
14309 pub union ListPaymentDetailsKind {
14310 Liquid: wire_cst_ListPaymentDetails_Liquid,
14311 Bitcoin: wire_cst_ListPaymentDetails_Bitcoin,
14312 nil__: (),
14313 }
14314 #[repr(C)]
14315 #[derive(Clone, Copy)]
14316 pub struct wire_cst_ListPaymentDetails_Liquid {
14317 asset_id: *mut wire_cst_list_prim_u_8_strict,
14318 destination: *mut wire_cst_list_prim_u_8_strict,
14319 }
14320 #[repr(C)]
14321 #[derive(Clone, Copy)]
14322 pub struct wire_cst_ListPaymentDetails_Bitcoin {
14323 address: *mut wire_cst_list_prim_u_8_strict,
14324 }
14325 #[repr(C)]
14326 #[derive(Clone, Copy)]
14327 pub struct wire_cst_list_payment_state {
14328 ptr: *mut i32,
14329 len: i32,
14330 }
14331 #[repr(C)]
14332 #[derive(Clone, Copy)]
14333 pub struct wire_cst_list_payment_type {
14334 ptr: *mut i32,
14335 len: i32,
14336 }
14337 #[repr(C)]
14338 #[derive(Clone, Copy)]
14339 pub struct wire_cst_list_payments_request {
14340 filters: *mut wire_cst_list_payment_type,
14341 states: *mut wire_cst_list_payment_state,
14342 from_timestamp: *mut i64,
14343 to_timestamp: *mut i64,
14344 offset: *mut u32,
14345 limit: *mut u32,
14346 details: *mut wire_cst_list_payment_details,
14347 sort_ascending: *mut bool,
14348 }
14349 #[repr(C)]
14350 #[derive(Clone, Copy)]
14351 pub struct wire_cst_list_prim_u_8_strict {
14352 ptr: *mut u8,
14353 len: i32,
14354 }
14355 #[repr(C)]
14356 #[derive(Clone, Copy)]
14357 pub struct wire_cst_list_rate {
14358 ptr: *mut wire_cst_rate,
14359 len: i32,
14360 }
14361 #[repr(C)]
14362 #[derive(Clone, Copy)]
14363 pub struct wire_cst_list_refundable_swap {
14364 ptr: *mut wire_cst_refundable_swap,
14365 len: i32,
14366 }
14367 #[repr(C)]
14368 #[derive(Clone, Copy)]
14369 pub struct wire_cst_list_route_hint {
14370 ptr: *mut wire_cst_route_hint,
14371 len: i32,
14372 }
14373 #[repr(C)]
14374 #[derive(Clone, Copy)]
14375 pub struct wire_cst_list_route_hint_hop {
14376 ptr: *mut wire_cst_route_hint_hop,
14377 len: i32,
14378 }
14379 #[repr(C)]
14380 #[derive(Clone, Copy)]
14381 pub struct wire_cst_ln_invoice {
14382 bolt11: *mut wire_cst_list_prim_u_8_strict,
14383 network: i32,
14384 payee_pubkey: *mut wire_cst_list_prim_u_8_strict,
14385 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14386 description: *mut wire_cst_list_prim_u_8_strict,
14387 description_hash: *mut wire_cst_list_prim_u_8_strict,
14388 amount_msat: *mut u64,
14389 timestamp: u64,
14390 expiry: u64,
14391 routing_hints: *mut wire_cst_list_route_hint,
14392 payment_secret: *mut wire_cst_list_prim_u_8_strict,
14393 min_final_cltv_expiry_delta: u64,
14394 }
14395 #[repr(C)]
14396 #[derive(Clone, Copy)]
14397 pub struct wire_cst_ln_offer {
14398 offer: *mut wire_cst_list_prim_u_8_strict,
14399 chains: *mut wire_cst_list_String,
14400 min_amount: *mut wire_cst_amount,
14401 description: *mut wire_cst_list_prim_u_8_strict,
14402 absolute_expiry: *mut u64,
14403 issuer: *mut wire_cst_list_prim_u_8_strict,
14404 signing_pubkey: *mut wire_cst_list_prim_u_8_strict,
14405 paths: *mut wire_cst_list_ln_offer_blinded_path,
14406 }
14407 #[repr(C)]
14408 #[derive(Clone, Copy)]
14409 pub struct wire_cst_ln_offer_blinded_path {
14410 blinded_hops: *mut wire_cst_list_String,
14411 }
14412 #[repr(C)]
14413 #[derive(Clone, Copy)]
14414 pub struct wire_cst_ln_url_auth_error {
14415 tag: i32,
14416 kind: LnUrlAuthErrorKind,
14417 }
14418 #[repr(C)]
14419 #[derive(Clone, Copy)]
14420 pub union LnUrlAuthErrorKind {
14421 Generic: wire_cst_LnUrlAuthError_Generic,
14422 InvalidUri: wire_cst_LnUrlAuthError_InvalidUri,
14423 ServiceConnectivity: wire_cst_LnUrlAuthError_ServiceConnectivity,
14424 nil__: (),
14425 }
14426 #[repr(C)]
14427 #[derive(Clone, Copy)]
14428 pub struct wire_cst_LnUrlAuthError_Generic {
14429 err: *mut wire_cst_list_prim_u_8_strict,
14430 }
14431 #[repr(C)]
14432 #[derive(Clone, Copy)]
14433 pub struct wire_cst_LnUrlAuthError_InvalidUri {
14434 err: *mut wire_cst_list_prim_u_8_strict,
14435 }
14436 #[repr(C)]
14437 #[derive(Clone, Copy)]
14438 pub struct wire_cst_LnUrlAuthError_ServiceConnectivity {
14439 err: *mut wire_cst_list_prim_u_8_strict,
14440 }
14441 #[repr(C)]
14442 #[derive(Clone, Copy)]
14443 pub struct wire_cst_ln_url_auth_request_data {
14444 k1: *mut wire_cst_list_prim_u_8_strict,
14445 action: *mut wire_cst_list_prim_u_8_strict,
14446 domain: *mut wire_cst_list_prim_u_8_strict,
14447 url: *mut wire_cst_list_prim_u_8_strict,
14448 }
14449 #[repr(C)]
14450 #[derive(Clone, Copy)]
14451 pub struct wire_cst_ln_url_callback_status {
14452 tag: i32,
14453 kind: LnUrlCallbackStatusKind,
14454 }
14455 #[repr(C)]
14456 #[derive(Clone, Copy)]
14457 pub union LnUrlCallbackStatusKind {
14458 ErrorStatus: wire_cst_LnUrlCallbackStatus_ErrorStatus,
14459 nil__: (),
14460 }
14461 #[repr(C)]
14462 #[derive(Clone, Copy)]
14463 pub struct wire_cst_LnUrlCallbackStatus_ErrorStatus {
14464 data: *mut wire_cst_ln_url_error_data,
14465 }
14466 #[repr(C)]
14467 #[derive(Clone, Copy)]
14468 pub struct wire_cst_ln_url_error_data {
14469 reason: *mut wire_cst_list_prim_u_8_strict,
14470 }
14471 #[repr(C)]
14472 #[derive(Clone, Copy)]
14473 pub struct wire_cst_ln_url_info {
14474 ln_address: *mut wire_cst_list_prim_u_8_strict,
14475 lnurl_pay_comment: *mut wire_cst_list_prim_u_8_strict,
14476 lnurl_pay_domain: *mut wire_cst_list_prim_u_8_strict,
14477 lnurl_pay_metadata: *mut wire_cst_list_prim_u_8_strict,
14478 lnurl_pay_success_action: *mut wire_cst_success_action_processed,
14479 lnurl_pay_unprocessed_success_action: *mut wire_cst_success_action,
14480 lnurl_withdraw_endpoint: *mut wire_cst_list_prim_u_8_strict,
14481 }
14482 #[repr(C)]
14483 #[derive(Clone, Copy)]
14484 pub struct wire_cst_ln_url_pay_error {
14485 tag: i32,
14486 kind: LnUrlPayErrorKind,
14487 }
14488 #[repr(C)]
14489 #[derive(Clone, Copy)]
14490 pub union LnUrlPayErrorKind {
14491 Generic: wire_cst_LnUrlPayError_Generic,
14492 InvalidAmount: wire_cst_LnUrlPayError_InvalidAmount,
14493 InvalidInvoice: wire_cst_LnUrlPayError_InvalidInvoice,
14494 InvalidNetwork: wire_cst_LnUrlPayError_InvalidNetwork,
14495 InvalidUri: wire_cst_LnUrlPayError_InvalidUri,
14496 InvoiceExpired: wire_cst_LnUrlPayError_InvoiceExpired,
14497 PaymentFailed: wire_cst_LnUrlPayError_PaymentFailed,
14498 PaymentTimeout: wire_cst_LnUrlPayError_PaymentTimeout,
14499 RouteNotFound: wire_cst_LnUrlPayError_RouteNotFound,
14500 RouteTooExpensive: wire_cst_LnUrlPayError_RouteTooExpensive,
14501 ServiceConnectivity: wire_cst_LnUrlPayError_ServiceConnectivity,
14502 nil__: (),
14503 }
14504 #[repr(C)]
14505 #[derive(Clone, Copy)]
14506 pub struct wire_cst_LnUrlPayError_Generic {
14507 err: *mut wire_cst_list_prim_u_8_strict,
14508 }
14509 #[repr(C)]
14510 #[derive(Clone, Copy)]
14511 pub struct wire_cst_LnUrlPayError_InvalidAmount {
14512 err: *mut wire_cst_list_prim_u_8_strict,
14513 }
14514 #[repr(C)]
14515 #[derive(Clone, Copy)]
14516 pub struct wire_cst_LnUrlPayError_InvalidInvoice {
14517 err: *mut wire_cst_list_prim_u_8_strict,
14518 }
14519 #[repr(C)]
14520 #[derive(Clone, Copy)]
14521 pub struct wire_cst_LnUrlPayError_InvalidNetwork {
14522 err: *mut wire_cst_list_prim_u_8_strict,
14523 }
14524 #[repr(C)]
14525 #[derive(Clone, Copy)]
14526 pub struct wire_cst_LnUrlPayError_InvalidUri {
14527 err: *mut wire_cst_list_prim_u_8_strict,
14528 }
14529 #[repr(C)]
14530 #[derive(Clone, Copy)]
14531 pub struct wire_cst_LnUrlPayError_InvoiceExpired {
14532 err: *mut wire_cst_list_prim_u_8_strict,
14533 }
14534 #[repr(C)]
14535 #[derive(Clone, Copy)]
14536 pub struct wire_cst_LnUrlPayError_PaymentFailed {
14537 err: *mut wire_cst_list_prim_u_8_strict,
14538 }
14539 #[repr(C)]
14540 #[derive(Clone, Copy)]
14541 pub struct wire_cst_LnUrlPayError_PaymentTimeout {
14542 err: *mut wire_cst_list_prim_u_8_strict,
14543 }
14544 #[repr(C)]
14545 #[derive(Clone, Copy)]
14546 pub struct wire_cst_LnUrlPayError_RouteNotFound {
14547 err: *mut wire_cst_list_prim_u_8_strict,
14548 }
14549 #[repr(C)]
14550 #[derive(Clone, Copy)]
14551 pub struct wire_cst_LnUrlPayError_RouteTooExpensive {
14552 err: *mut wire_cst_list_prim_u_8_strict,
14553 }
14554 #[repr(C)]
14555 #[derive(Clone, Copy)]
14556 pub struct wire_cst_LnUrlPayError_ServiceConnectivity {
14557 err: *mut wire_cst_list_prim_u_8_strict,
14558 }
14559 #[repr(C)]
14560 #[derive(Clone, Copy)]
14561 pub struct wire_cst_ln_url_pay_error_data {
14562 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14563 reason: *mut wire_cst_list_prim_u_8_strict,
14564 }
14565 #[repr(C)]
14566 #[derive(Clone, Copy)]
14567 pub struct wire_cst_ln_url_pay_request {
14568 prepare_response: wire_cst_prepare_ln_url_pay_response,
14569 }
14570 #[repr(C)]
14571 #[derive(Clone, Copy)]
14572 pub struct wire_cst_ln_url_pay_request_data {
14573 callback: *mut wire_cst_list_prim_u_8_strict,
14574 min_sendable: u64,
14575 max_sendable: u64,
14576 metadata_str: *mut wire_cst_list_prim_u_8_strict,
14577 comment_allowed: u16,
14578 domain: *mut wire_cst_list_prim_u_8_strict,
14579 allows_nostr: bool,
14580 nostr_pubkey: *mut wire_cst_list_prim_u_8_strict,
14581 ln_address: *mut wire_cst_list_prim_u_8_strict,
14582 }
14583 #[repr(C)]
14584 #[derive(Clone, Copy)]
14585 pub struct wire_cst_ln_url_pay_result {
14586 tag: i32,
14587 kind: LnUrlPayResultKind,
14588 }
14589 #[repr(C)]
14590 #[derive(Clone, Copy)]
14591 pub union LnUrlPayResultKind {
14592 EndpointSuccess: wire_cst_LnUrlPayResult_EndpointSuccess,
14593 EndpointError: wire_cst_LnUrlPayResult_EndpointError,
14594 PayError: wire_cst_LnUrlPayResult_PayError,
14595 nil__: (),
14596 }
14597 #[repr(C)]
14598 #[derive(Clone, Copy)]
14599 pub struct wire_cst_LnUrlPayResult_EndpointSuccess {
14600 data: *mut wire_cst_ln_url_pay_success_data,
14601 }
14602 #[repr(C)]
14603 #[derive(Clone, Copy)]
14604 pub struct wire_cst_LnUrlPayResult_EndpointError {
14605 data: *mut wire_cst_ln_url_error_data,
14606 }
14607 #[repr(C)]
14608 #[derive(Clone, Copy)]
14609 pub struct wire_cst_LnUrlPayResult_PayError {
14610 data: *mut wire_cst_ln_url_pay_error_data,
14611 }
14612 #[repr(C)]
14613 #[derive(Clone, Copy)]
14614 pub struct wire_cst_ln_url_pay_success_data {
14615 payment: wire_cst_payment,
14616 success_action: *mut wire_cst_success_action_processed,
14617 }
14618 #[repr(C)]
14619 #[derive(Clone, Copy)]
14620 pub struct wire_cst_ln_url_withdraw_error {
14621 tag: i32,
14622 kind: LnUrlWithdrawErrorKind,
14623 }
14624 #[repr(C)]
14625 #[derive(Clone, Copy)]
14626 pub union LnUrlWithdrawErrorKind {
14627 Generic: wire_cst_LnUrlWithdrawError_Generic,
14628 InvalidAmount: wire_cst_LnUrlWithdrawError_InvalidAmount,
14629 InvalidInvoice: wire_cst_LnUrlWithdrawError_InvalidInvoice,
14630 InvalidUri: wire_cst_LnUrlWithdrawError_InvalidUri,
14631 InvoiceNoRoutingHints: wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints,
14632 ServiceConnectivity: wire_cst_LnUrlWithdrawError_ServiceConnectivity,
14633 nil__: (),
14634 }
14635 #[repr(C)]
14636 #[derive(Clone, Copy)]
14637 pub struct wire_cst_LnUrlWithdrawError_Generic {
14638 err: *mut wire_cst_list_prim_u_8_strict,
14639 }
14640 #[repr(C)]
14641 #[derive(Clone, Copy)]
14642 pub struct wire_cst_LnUrlWithdrawError_InvalidAmount {
14643 err: *mut wire_cst_list_prim_u_8_strict,
14644 }
14645 #[repr(C)]
14646 #[derive(Clone, Copy)]
14647 pub struct wire_cst_LnUrlWithdrawError_InvalidInvoice {
14648 err: *mut wire_cst_list_prim_u_8_strict,
14649 }
14650 #[repr(C)]
14651 #[derive(Clone, Copy)]
14652 pub struct wire_cst_LnUrlWithdrawError_InvalidUri {
14653 err: *mut wire_cst_list_prim_u_8_strict,
14654 }
14655 #[repr(C)]
14656 #[derive(Clone, Copy)]
14657 pub struct wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints {
14658 err: *mut wire_cst_list_prim_u_8_strict,
14659 }
14660 #[repr(C)]
14661 #[derive(Clone, Copy)]
14662 pub struct wire_cst_LnUrlWithdrawError_ServiceConnectivity {
14663 err: *mut wire_cst_list_prim_u_8_strict,
14664 }
14665 #[repr(C)]
14666 #[derive(Clone, Copy)]
14667 pub struct wire_cst_ln_url_withdraw_request {
14668 data: wire_cst_ln_url_withdraw_request_data,
14669 amount_msat: u64,
14670 description: *mut wire_cst_list_prim_u_8_strict,
14671 }
14672 #[repr(C)]
14673 #[derive(Clone, Copy)]
14674 pub struct wire_cst_ln_url_withdraw_request_data {
14675 callback: *mut wire_cst_list_prim_u_8_strict,
14676 k1: *mut wire_cst_list_prim_u_8_strict,
14677 default_description: *mut wire_cst_list_prim_u_8_strict,
14678 min_withdrawable: u64,
14679 max_withdrawable: u64,
14680 }
14681 #[repr(C)]
14682 #[derive(Clone, Copy)]
14683 pub struct wire_cst_ln_url_withdraw_result {
14684 tag: i32,
14685 kind: LnUrlWithdrawResultKind,
14686 }
14687 #[repr(C)]
14688 #[derive(Clone, Copy)]
14689 pub union LnUrlWithdrawResultKind {
14690 Ok: wire_cst_LnUrlWithdrawResult_Ok,
14691 Timeout: wire_cst_LnUrlWithdrawResult_Timeout,
14692 ErrorStatus: wire_cst_LnUrlWithdrawResult_ErrorStatus,
14693 nil__: (),
14694 }
14695 #[repr(C)]
14696 #[derive(Clone, Copy)]
14697 pub struct wire_cst_LnUrlWithdrawResult_Ok {
14698 data: *mut wire_cst_ln_url_withdraw_success_data,
14699 }
14700 #[repr(C)]
14701 #[derive(Clone, Copy)]
14702 pub struct wire_cst_LnUrlWithdrawResult_Timeout {
14703 data: *mut wire_cst_ln_url_withdraw_success_data,
14704 }
14705 #[repr(C)]
14706 #[derive(Clone, Copy)]
14707 pub struct wire_cst_LnUrlWithdrawResult_ErrorStatus {
14708 data: *mut wire_cst_ln_url_error_data,
14709 }
14710 #[repr(C)]
14711 #[derive(Clone, Copy)]
14712 pub struct wire_cst_ln_url_withdraw_success_data {
14713 invoice: wire_cst_ln_invoice,
14714 }
14715 #[repr(C)]
14716 #[derive(Clone, Copy)]
14717 pub struct wire_cst_locale_overrides {
14718 locale: *mut wire_cst_list_prim_u_8_strict,
14719 spacing: *mut u32,
14720 symbol: wire_cst_symbol,
14721 }
14722 #[repr(C)]
14723 #[derive(Clone, Copy)]
14724 pub struct wire_cst_localized_name {
14725 locale: *mut wire_cst_list_prim_u_8_strict,
14726 name: *mut wire_cst_list_prim_u_8_strict,
14727 }
14728 #[repr(C)]
14729 #[derive(Clone, Copy)]
14730 pub struct wire_cst_log_entry {
14731 line: *mut wire_cst_list_prim_u_8_strict,
14732 level: *mut wire_cst_list_prim_u_8_strict,
14733 }
14734 #[repr(C)]
14735 #[derive(Clone, Copy)]
14736 pub struct wire_cst_message_success_action_data {
14737 message: *mut wire_cst_list_prim_u_8_strict,
14738 }
14739 #[repr(C)]
14740 #[derive(Clone, Copy)]
14741 pub struct wire_cst_onchain_payment_limits_response {
14742 send: wire_cst_limits,
14743 receive: wire_cst_limits,
14744 }
14745 #[repr(C)]
14746 #[derive(Clone, Copy)]
14747 pub struct wire_cst_pay_amount {
14748 tag: i32,
14749 kind: PayAmountKind,
14750 }
14751 #[repr(C)]
14752 #[derive(Clone, Copy)]
14753 pub union PayAmountKind {
14754 Bitcoin: wire_cst_PayAmount_Bitcoin,
14755 Asset: wire_cst_PayAmount_Asset,
14756 nil__: (),
14757 }
14758 #[repr(C)]
14759 #[derive(Clone, Copy)]
14760 pub struct wire_cst_PayAmount_Bitcoin {
14761 receiver_amount_sat: u64,
14762 }
14763 #[repr(C)]
14764 #[derive(Clone, Copy)]
14765 pub struct wire_cst_PayAmount_Asset {
14766 asset_id: *mut wire_cst_list_prim_u_8_strict,
14767 receiver_amount: f64,
14768 estimate_asset_fees: *mut bool,
14769 }
14770 #[repr(C)]
14771 #[derive(Clone, Copy)]
14772 pub struct wire_cst_pay_onchain_request {
14773 address: *mut wire_cst_list_prim_u_8_strict,
14774 prepare_response: wire_cst_prepare_pay_onchain_response,
14775 }
14776 #[repr(C)]
14777 #[derive(Clone, Copy)]
14778 pub struct wire_cst_payment {
14779 destination: *mut wire_cst_list_prim_u_8_strict,
14780 tx_id: *mut wire_cst_list_prim_u_8_strict,
14781 unblinding_data: *mut wire_cst_list_prim_u_8_strict,
14782 timestamp: u32,
14783 amount_sat: u64,
14784 fees_sat: u64,
14785 swapper_fees_sat: *mut u64,
14786 payment_type: i32,
14787 status: i32,
14788 details: wire_cst_payment_details,
14789 }
14790 #[repr(C)]
14791 #[derive(Clone, Copy)]
14792 pub struct wire_cst_payment_details {
14793 tag: i32,
14794 kind: PaymentDetailsKind,
14795 }
14796 #[repr(C)]
14797 #[derive(Clone, Copy)]
14798 pub union PaymentDetailsKind {
14799 Lightning: wire_cst_PaymentDetails_Lightning,
14800 Liquid: wire_cst_PaymentDetails_Liquid,
14801 Bitcoin: wire_cst_PaymentDetails_Bitcoin,
14802 nil__: (),
14803 }
14804 #[repr(C)]
14805 #[derive(Clone, Copy)]
14806 pub struct wire_cst_PaymentDetails_Lightning {
14807 swap_id: *mut wire_cst_list_prim_u_8_strict,
14808 description: *mut wire_cst_list_prim_u_8_strict,
14809 liquid_expiration_blockheight: u32,
14810 preimage: *mut wire_cst_list_prim_u_8_strict,
14811 invoice: *mut wire_cst_list_prim_u_8_strict,
14812 bolt12_offer: *mut wire_cst_list_prim_u_8_strict,
14813 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14814 destination_pubkey: *mut wire_cst_list_prim_u_8_strict,
14815 lnurl_info: *mut wire_cst_ln_url_info,
14816 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14817 claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
14818 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
14819 refund_tx_amount_sat: *mut u64,
14820 }
14821 #[repr(C)]
14822 #[derive(Clone, Copy)]
14823 pub struct wire_cst_PaymentDetails_Liquid {
14824 destination: *mut wire_cst_list_prim_u_8_strict,
14825 description: *mut wire_cst_list_prim_u_8_strict,
14826 asset_id: *mut wire_cst_list_prim_u_8_strict,
14827 asset_info: *mut wire_cst_asset_info,
14828 lnurl_info: *mut wire_cst_ln_url_info,
14829 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14830 }
14831 #[repr(C)]
14832 #[derive(Clone, Copy)]
14833 pub struct wire_cst_PaymentDetails_Bitcoin {
14834 swap_id: *mut wire_cst_list_prim_u_8_strict,
14835 description: *mut wire_cst_list_prim_u_8_strict,
14836 auto_accepted_fees: bool,
14837 liquid_expiration_blockheight: *mut u32,
14838 bitcoin_expiration_blockheight: *mut u32,
14839 claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
14840 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
14841 refund_tx_amount_sat: *mut u64,
14842 }
14843 #[repr(C)]
14844 #[derive(Clone, Copy)]
14845 pub struct wire_cst_payment_error {
14846 tag: i32,
14847 kind: PaymentErrorKind,
14848 }
14849 #[repr(C)]
14850 #[derive(Clone, Copy)]
14851 pub union PaymentErrorKind {
14852 AmountMissing: wire_cst_PaymentError_AmountMissing,
14853 AssetError: wire_cst_PaymentError_AssetError,
14854 InvalidNetwork: wire_cst_PaymentError_InvalidNetwork,
14855 Generic: wire_cst_PaymentError_Generic,
14856 InvalidDescription: wire_cst_PaymentError_InvalidDescription,
14857 InvalidInvoice: wire_cst_PaymentError_InvalidInvoice,
14858 ReceiveError: wire_cst_PaymentError_ReceiveError,
14859 Refunded: wire_cst_PaymentError_Refunded,
14860 SendError: wire_cst_PaymentError_SendError,
14861 SignerError: wire_cst_PaymentError_SignerError,
14862 nil__: (),
14863 }
14864 #[repr(C)]
14865 #[derive(Clone, Copy)]
14866 pub struct wire_cst_PaymentError_AmountMissing {
14867 err: *mut wire_cst_list_prim_u_8_strict,
14868 }
14869 #[repr(C)]
14870 #[derive(Clone, Copy)]
14871 pub struct wire_cst_PaymentError_AssetError {
14872 err: *mut wire_cst_list_prim_u_8_strict,
14873 }
14874 #[repr(C)]
14875 #[derive(Clone, Copy)]
14876 pub struct wire_cst_PaymentError_InvalidNetwork {
14877 err: *mut wire_cst_list_prim_u_8_strict,
14878 }
14879 #[repr(C)]
14880 #[derive(Clone, Copy)]
14881 pub struct wire_cst_PaymentError_Generic {
14882 err: *mut wire_cst_list_prim_u_8_strict,
14883 }
14884 #[repr(C)]
14885 #[derive(Clone, Copy)]
14886 pub struct wire_cst_PaymentError_InvalidDescription {
14887 err: *mut wire_cst_list_prim_u_8_strict,
14888 }
14889 #[repr(C)]
14890 #[derive(Clone, Copy)]
14891 pub struct wire_cst_PaymentError_InvalidInvoice {
14892 err: *mut wire_cst_list_prim_u_8_strict,
14893 }
14894 #[repr(C)]
14895 #[derive(Clone, Copy)]
14896 pub struct wire_cst_PaymentError_ReceiveError {
14897 err: *mut wire_cst_list_prim_u_8_strict,
14898 }
14899 #[repr(C)]
14900 #[derive(Clone, Copy)]
14901 pub struct wire_cst_PaymentError_Refunded {
14902 err: *mut wire_cst_list_prim_u_8_strict,
14903 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
14904 }
14905 #[repr(C)]
14906 #[derive(Clone, Copy)]
14907 pub struct wire_cst_PaymentError_SendError {
14908 err: *mut wire_cst_list_prim_u_8_strict,
14909 }
14910 #[repr(C)]
14911 #[derive(Clone, Copy)]
14912 pub struct wire_cst_PaymentError_SignerError {
14913 err: *mut wire_cst_list_prim_u_8_strict,
14914 }
14915 #[repr(C)]
14916 #[derive(Clone, Copy)]
14917 pub struct wire_cst_prepare_buy_bitcoin_request {
14918 provider: i32,
14919 amount_sat: u64,
14920 }
14921 #[repr(C)]
14922 #[derive(Clone, Copy)]
14923 pub struct wire_cst_prepare_buy_bitcoin_response {
14924 provider: i32,
14925 amount_sat: u64,
14926 fees_sat: u64,
14927 }
14928 #[repr(C)]
14929 #[derive(Clone, Copy)]
14930 pub struct wire_cst_prepare_ln_url_pay_request {
14931 data: wire_cst_ln_url_pay_request_data,
14932 amount: wire_cst_pay_amount,
14933 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14934 comment: *mut wire_cst_list_prim_u_8_strict,
14935 validate_success_action_url: *mut bool,
14936 }
14937 #[repr(C)]
14938 #[derive(Clone, Copy)]
14939 pub struct wire_cst_prepare_ln_url_pay_response {
14940 destination: wire_cst_send_destination,
14941 fees_sat: u64,
14942 data: wire_cst_ln_url_pay_request_data,
14943 comment: *mut wire_cst_list_prim_u_8_strict,
14944 success_action: *mut wire_cst_success_action,
14945 }
14946 #[repr(C)]
14947 #[derive(Clone, Copy)]
14948 pub struct wire_cst_prepare_pay_onchain_request {
14949 amount: wire_cst_pay_amount,
14950 fee_rate_sat_per_vbyte: *mut u32,
14951 }
14952 #[repr(C)]
14953 #[derive(Clone, Copy)]
14954 pub struct wire_cst_prepare_pay_onchain_response {
14955 receiver_amount_sat: u64,
14956 claim_fees_sat: u64,
14957 total_fees_sat: u64,
14958 }
14959 #[repr(C)]
14960 #[derive(Clone, Copy)]
14961 pub struct wire_cst_prepare_receive_request {
14962 payment_method: i32,
14963 amount: *mut wire_cst_receive_amount,
14964 }
14965 #[repr(C)]
14966 #[derive(Clone, Copy)]
14967 pub struct wire_cst_prepare_receive_response {
14968 payment_method: i32,
14969 amount: *mut wire_cst_receive_amount,
14970 fees_sat: u64,
14971 min_payer_amount_sat: *mut u64,
14972 max_payer_amount_sat: *mut u64,
14973 swapper_feerate: *mut f64,
14974 }
14975 #[repr(C)]
14976 #[derive(Clone, Copy)]
14977 pub struct wire_cst_prepare_refund_request {
14978 swap_address: *mut wire_cst_list_prim_u_8_strict,
14979 refund_address: *mut wire_cst_list_prim_u_8_strict,
14980 fee_rate_sat_per_vbyte: u32,
14981 }
14982 #[repr(C)]
14983 #[derive(Clone, Copy)]
14984 pub struct wire_cst_prepare_refund_response {
14985 tx_vsize: u32,
14986 tx_fee_sat: u64,
14987 last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
14988 }
14989 #[repr(C)]
14990 #[derive(Clone, Copy)]
14991 pub struct wire_cst_prepare_send_request {
14992 destination: *mut wire_cst_list_prim_u_8_strict,
14993 amount: *mut wire_cst_pay_amount,
14994 }
14995 #[repr(C)]
14996 #[derive(Clone, Copy)]
14997 pub struct wire_cst_prepare_send_response {
14998 destination: wire_cst_send_destination,
14999 fees_sat: *mut u64,
15000 estimated_asset_fees: *mut f64,
15001 }
15002 #[repr(C)]
15003 #[derive(Clone, Copy)]
15004 pub struct wire_cst_rate {
15005 coin: *mut wire_cst_list_prim_u_8_strict,
15006 value: f64,
15007 }
15008 #[repr(C)]
15009 #[derive(Clone, Copy)]
15010 pub struct wire_cst_receive_amount {
15011 tag: i32,
15012 kind: ReceiveAmountKind,
15013 }
15014 #[repr(C)]
15015 #[derive(Clone, Copy)]
15016 pub union ReceiveAmountKind {
15017 Bitcoin: wire_cst_ReceiveAmount_Bitcoin,
15018 Asset: wire_cst_ReceiveAmount_Asset,
15019 nil__: (),
15020 }
15021 #[repr(C)]
15022 #[derive(Clone, Copy)]
15023 pub struct wire_cst_ReceiveAmount_Bitcoin {
15024 payer_amount_sat: u64,
15025 }
15026 #[repr(C)]
15027 #[derive(Clone, Copy)]
15028 pub struct wire_cst_ReceiveAmount_Asset {
15029 asset_id: *mut wire_cst_list_prim_u_8_strict,
15030 payer_amount: *mut f64,
15031 }
15032 #[repr(C)]
15033 #[derive(Clone, Copy)]
15034 pub struct wire_cst_receive_payment_request {
15035 prepare_response: wire_cst_prepare_receive_response,
15036 description: *mut wire_cst_list_prim_u_8_strict,
15037 use_description_hash: *mut bool,
15038 }
15039 #[repr(C)]
15040 #[derive(Clone, Copy)]
15041 pub struct wire_cst_receive_payment_response {
15042 destination: *mut wire_cst_list_prim_u_8_strict,
15043 }
15044 #[repr(C)]
15045 #[derive(Clone, Copy)]
15046 pub struct wire_cst_recommended_fees {
15047 fastest_fee: u64,
15048 half_hour_fee: u64,
15049 hour_fee: u64,
15050 economy_fee: u64,
15051 minimum_fee: u64,
15052 }
15053 #[repr(C)]
15054 #[derive(Clone, Copy)]
15055 pub struct wire_cst_refund_request {
15056 swap_address: *mut wire_cst_list_prim_u_8_strict,
15057 refund_address: *mut wire_cst_list_prim_u_8_strict,
15058 fee_rate_sat_per_vbyte: u32,
15059 }
15060 #[repr(C)]
15061 #[derive(Clone, Copy)]
15062 pub struct wire_cst_refund_response {
15063 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15064 }
15065 #[repr(C)]
15066 #[derive(Clone, Copy)]
15067 pub struct wire_cst_refundable_swap {
15068 swap_address: *mut wire_cst_list_prim_u_8_strict,
15069 timestamp: u32,
15070 amount_sat: u64,
15071 last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15072 }
15073 #[repr(C)]
15074 #[derive(Clone, Copy)]
15075 pub struct wire_cst_restore_request {
15076 backup_path: *mut wire_cst_list_prim_u_8_strict,
15077 }
15078 #[repr(C)]
15079 #[derive(Clone, Copy)]
15080 pub struct wire_cst_route_hint {
15081 hops: *mut wire_cst_list_route_hint_hop,
15082 }
15083 #[repr(C)]
15084 #[derive(Clone, Copy)]
15085 pub struct wire_cst_route_hint_hop {
15086 src_node_id: *mut wire_cst_list_prim_u_8_strict,
15087 short_channel_id: *mut wire_cst_list_prim_u_8_strict,
15088 fees_base_msat: u32,
15089 fees_proportional_millionths: u32,
15090 cltv_expiry_delta: u64,
15091 htlc_minimum_msat: *mut u64,
15092 htlc_maximum_msat: *mut u64,
15093 }
15094 #[repr(C)]
15095 #[derive(Clone, Copy)]
15096 pub struct wire_cst_sdk_error {
15097 tag: i32,
15098 kind: SdkErrorKind,
15099 }
15100 #[repr(C)]
15101 #[derive(Clone, Copy)]
15102 pub union SdkErrorKind {
15103 Generic: wire_cst_SdkError_Generic,
15104 ServiceConnectivity: wire_cst_SdkError_ServiceConnectivity,
15105 nil__: (),
15106 }
15107 #[repr(C)]
15108 #[derive(Clone, Copy)]
15109 pub struct wire_cst_SdkError_Generic {
15110 err: *mut wire_cst_list_prim_u_8_strict,
15111 }
15112 #[repr(C)]
15113 #[derive(Clone, Copy)]
15114 pub struct wire_cst_SdkError_ServiceConnectivity {
15115 err: *mut wire_cst_list_prim_u_8_strict,
15116 }
15117 #[repr(C)]
15118 #[derive(Clone, Copy)]
15119 pub struct wire_cst_sdk_event {
15120 tag: i32,
15121 kind: SdkEventKind,
15122 }
15123 #[repr(C)]
15124 #[derive(Clone, Copy)]
15125 pub union SdkEventKind {
15126 PaymentFailed: wire_cst_SdkEvent_PaymentFailed,
15127 PaymentPending: wire_cst_SdkEvent_PaymentPending,
15128 PaymentRefundable: wire_cst_SdkEvent_PaymentRefundable,
15129 PaymentRefunded: wire_cst_SdkEvent_PaymentRefunded,
15130 PaymentRefundPending: wire_cst_SdkEvent_PaymentRefundPending,
15131 PaymentSucceeded: wire_cst_SdkEvent_PaymentSucceeded,
15132 PaymentWaitingConfirmation: wire_cst_SdkEvent_PaymentWaitingConfirmation,
15133 PaymentWaitingFeeAcceptance: wire_cst_SdkEvent_PaymentWaitingFeeAcceptance,
15134 DataSynced: wire_cst_SdkEvent_DataSynced,
15135 nil__: (),
15136 }
15137 #[repr(C)]
15138 #[derive(Clone, Copy)]
15139 pub struct wire_cst_SdkEvent_PaymentFailed {
15140 details: *mut wire_cst_payment,
15141 }
15142 #[repr(C)]
15143 #[derive(Clone, Copy)]
15144 pub struct wire_cst_SdkEvent_PaymentPending {
15145 details: *mut wire_cst_payment,
15146 }
15147 #[repr(C)]
15148 #[derive(Clone, Copy)]
15149 pub struct wire_cst_SdkEvent_PaymentRefundable {
15150 details: *mut wire_cst_payment,
15151 }
15152 #[repr(C)]
15153 #[derive(Clone, Copy)]
15154 pub struct wire_cst_SdkEvent_PaymentRefunded {
15155 details: *mut wire_cst_payment,
15156 }
15157 #[repr(C)]
15158 #[derive(Clone, Copy)]
15159 pub struct wire_cst_SdkEvent_PaymentRefundPending {
15160 details: *mut wire_cst_payment,
15161 }
15162 #[repr(C)]
15163 #[derive(Clone, Copy)]
15164 pub struct wire_cst_SdkEvent_PaymentSucceeded {
15165 details: *mut wire_cst_payment,
15166 }
15167 #[repr(C)]
15168 #[derive(Clone, Copy)]
15169 pub struct wire_cst_SdkEvent_PaymentWaitingConfirmation {
15170 details: *mut wire_cst_payment,
15171 }
15172 #[repr(C)]
15173 #[derive(Clone, Copy)]
15174 pub struct wire_cst_SdkEvent_PaymentWaitingFeeAcceptance {
15175 details: *mut wire_cst_payment,
15176 }
15177 #[repr(C)]
15178 #[derive(Clone, Copy)]
15179 pub struct wire_cst_SdkEvent_DataSynced {
15180 did_pull_new_records: bool,
15181 }
15182 #[repr(C)]
15183 #[derive(Clone, Copy)]
15184 pub struct wire_cst_send_destination {
15185 tag: i32,
15186 kind: SendDestinationKind,
15187 }
15188 #[repr(C)]
15189 #[derive(Clone, Copy)]
15190 pub union SendDestinationKind {
15191 LiquidAddress: wire_cst_SendDestination_LiquidAddress,
15192 Bolt11: wire_cst_SendDestination_Bolt11,
15193 Bolt12: wire_cst_SendDestination_Bolt12,
15194 nil__: (),
15195 }
15196 #[repr(C)]
15197 #[derive(Clone, Copy)]
15198 pub struct wire_cst_SendDestination_LiquidAddress {
15199 address_data: *mut wire_cst_liquid_address_data,
15200 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15201 }
15202 #[repr(C)]
15203 #[derive(Clone, Copy)]
15204 pub struct wire_cst_SendDestination_Bolt11 {
15205 invoice: *mut wire_cst_ln_invoice,
15206 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15207 }
15208 #[repr(C)]
15209 #[derive(Clone, Copy)]
15210 pub struct wire_cst_SendDestination_Bolt12 {
15211 offer: *mut wire_cst_ln_offer,
15212 receiver_amount_sat: u64,
15213 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15214 }
15215 #[repr(C)]
15216 #[derive(Clone, Copy)]
15217 pub struct wire_cst_send_payment_request {
15218 prepare_response: wire_cst_prepare_send_response,
15219 use_asset_fees: *mut bool,
15220 }
15221 #[repr(C)]
15222 #[derive(Clone, Copy)]
15223 pub struct wire_cst_send_payment_response {
15224 payment: wire_cst_payment,
15225 }
15226 #[repr(C)]
15227 #[derive(Clone, Copy)]
15228 pub struct wire_cst_sign_message_request {
15229 message: *mut wire_cst_list_prim_u_8_strict,
15230 }
15231 #[repr(C)]
15232 #[derive(Clone, Copy)]
15233 pub struct wire_cst_sign_message_response {
15234 signature: *mut wire_cst_list_prim_u_8_strict,
15235 }
15236 #[repr(C)]
15237 #[derive(Clone, Copy)]
15238 pub struct wire_cst_success_action {
15239 tag: i32,
15240 kind: SuccessActionKind,
15241 }
15242 #[repr(C)]
15243 #[derive(Clone, Copy)]
15244 pub union SuccessActionKind {
15245 Aes: wire_cst_SuccessAction_Aes,
15246 Message: wire_cst_SuccessAction_Message,
15247 Url: wire_cst_SuccessAction_Url,
15248 nil__: (),
15249 }
15250 #[repr(C)]
15251 #[derive(Clone, Copy)]
15252 pub struct wire_cst_SuccessAction_Aes {
15253 data: *mut wire_cst_aes_success_action_data,
15254 }
15255 #[repr(C)]
15256 #[derive(Clone, Copy)]
15257 pub struct wire_cst_SuccessAction_Message {
15258 data: *mut wire_cst_message_success_action_data,
15259 }
15260 #[repr(C)]
15261 #[derive(Clone, Copy)]
15262 pub struct wire_cst_SuccessAction_Url {
15263 data: *mut wire_cst_url_success_action_data,
15264 }
15265 #[repr(C)]
15266 #[derive(Clone, Copy)]
15267 pub struct wire_cst_success_action_processed {
15268 tag: i32,
15269 kind: SuccessActionProcessedKind,
15270 }
15271 #[repr(C)]
15272 #[derive(Clone, Copy)]
15273 pub union SuccessActionProcessedKind {
15274 Aes: wire_cst_SuccessActionProcessed_Aes,
15275 Message: wire_cst_SuccessActionProcessed_Message,
15276 Url: wire_cst_SuccessActionProcessed_Url,
15277 nil__: (),
15278 }
15279 #[repr(C)]
15280 #[derive(Clone, Copy)]
15281 pub struct wire_cst_SuccessActionProcessed_Aes {
15282 result: *mut wire_cst_aes_success_action_data_result,
15283 }
15284 #[repr(C)]
15285 #[derive(Clone, Copy)]
15286 pub struct wire_cst_SuccessActionProcessed_Message {
15287 data: *mut wire_cst_message_success_action_data,
15288 }
15289 #[repr(C)]
15290 #[derive(Clone, Copy)]
15291 pub struct wire_cst_SuccessActionProcessed_Url {
15292 data: *mut wire_cst_url_success_action_data,
15293 }
15294 #[repr(C)]
15295 #[derive(Clone, Copy)]
15296 pub struct wire_cst_symbol {
15297 grapheme: *mut wire_cst_list_prim_u_8_strict,
15298 template: *mut wire_cst_list_prim_u_8_strict,
15299 rtl: *mut bool,
15300 position: *mut u32,
15301 }
15302 #[repr(C)]
15303 #[derive(Clone, Copy)]
15304 pub struct wire_cst_url_success_action_data {
15305 description: *mut wire_cst_list_prim_u_8_strict,
15306 url: *mut wire_cst_list_prim_u_8_strict,
15307 matches_callback_domain: bool,
15308 }
15309 #[repr(C)]
15310 #[derive(Clone, Copy)]
15311 pub struct wire_cst_wallet_info {
15312 balance_sat: u64,
15313 pending_send_sat: u64,
15314 pending_receive_sat: u64,
15315 fingerprint: *mut wire_cst_list_prim_u_8_strict,
15316 pubkey: *mut wire_cst_list_prim_u_8_strict,
15317 asset_balances: *mut wire_cst_list_asset_balance,
15318 }
15319}
15320#[cfg(not(target_family = "wasm"))]
15321pub use io::*;