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 = 464449310;
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_create_bolt12_invoice_impl(
275 port_: flutter_rust_bridge::for_generated::MessagePort,
276 that: impl CstDecode<
277 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
278 >,
279 req: impl CstDecode<crate::model::CreateBolt12InvoiceRequest>,
280) {
281 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
282 flutter_rust_bridge::for_generated::TaskInfo {
283 debug_name: "BindingLiquidSdk_create_bolt12_invoice",
284 port: Some(port_),
285 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
286 },
287 move || {
288 let api_that = that.cst_decode();
289 let api_req = req.cst_decode();
290 move |context| async move {
291 transform_result_dco::<_, _, crate::error::PaymentError>(
292 (move || async move {
293 let mut api_that_guard = None;
294 let decode_indices_ =
295 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
296 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
297 &api_that, 0, false,
298 )],
299 );
300 for i in decode_indices_ {
301 match i {
302 0 => {
303 api_that_guard =
304 Some(api_that.lockable_decode_async_ref().await)
305 }
306 _ => unreachable!(),
307 }
308 }
309 let api_that_guard = api_that_guard.unwrap();
310 let output_ok = crate::bindings::BindingLiquidSdk::create_bolt12_invoice(
311 &*api_that_guard,
312 api_req,
313 )
314 .await?;
315 Ok(output_ok)
316 })()
317 .await,
318 )
319 }
320 },
321 )
322}
323fn wire__crate__bindings__BindingLiquidSdk_disconnect_impl(
324 port_: flutter_rust_bridge::for_generated::MessagePort,
325 that: impl CstDecode<
326 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
327 >,
328) {
329 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
330 flutter_rust_bridge::for_generated::TaskInfo {
331 debug_name: "BindingLiquidSdk_disconnect",
332 port: Some(port_),
333 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
334 },
335 move || {
336 let api_that = that.cst_decode();
337 move |context| async move {
338 transform_result_dco::<_, _, crate::error::SdkError>(
339 (move || async move {
340 let mut api_that_guard = None;
341 let decode_indices_ =
342 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
343 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
344 &api_that, 0, false,
345 )],
346 );
347 for i in decode_indices_ {
348 match i {
349 0 => {
350 api_that_guard =
351 Some(api_that.lockable_decode_async_ref().await)
352 }
353 _ => unreachable!(),
354 }
355 }
356 let api_that_guard = api_that_guard.unwrap();
357 let output_ok =
358 crate::bindings::BindingLiquidSdk::disconnect(&*api_that_guard).await?;
359 Ok(output_ok)
360 })()
361 .await,
362 )
363 }
364 },
365 )
366}
367fn wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(
368 that: impl CstDecode<
369 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
370 >,
371) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
372 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
373 flutter_rust_bridge::for_generated::TaskInfo {
374 debug_name: "BindingLiquidSdk_empty_wallet_cache",
375 port: None,
376 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
377 },
378 move || {
379 let api_that = that.cst_decode();
380 transform_result_dco::<_, _, crate::error::SdkError>((move || {
381 let mut api_that_guard = None;
382 let decode_indices_ =
383 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
384 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
385 &api_that, 0, false,
386 ),
387 ]);
388 for i in decode_indices_ {
389 match i {
390 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
391 _ => unreachable!(),
392 }
393 }
394 let api_that_guard = api_that_guard.unwrap();
395 let output_ok =
396 crate::bindings::BindingLiquidSdk::empty_wallet_cache(&*api_that_guard)?;
397 Ok(output_ok)
398 })())
399 },
400 )
401}
402fn wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(
403 port_: flutter_rust_bridge::for_generated::MessagePort,
404 that: impl CstDecode<
405 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
406 >,
407) {
408 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
409 flutter_rust_bridge::for_generated::TaskInfo {
410 debug_name: "BindingLiquidSdk_fetch_fiat_rates",
411 port: Some(port_),
412 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
413 },
414 move || {
415 let api_that = that.cst_decode();
416 move |context| async move {
417 transform_result_dco::<_, _, crate::error::SdkError>(
418 (move || async move {
419 let mut api_that_guard = None;
420 let decode_indices_ =
421 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
422 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
423 &api_that, 0, false,
424 )],
425 );
426 for i in decode_indices_ {
427 match i {
428 0 => {
429 api_that_guard =
430 Some(api_that.lockable_decode_async_ref().await)
431 }
432 _ => unreachable!(),
433 }
434 }
435 let api_that_guard = api_that_guard.unwrap();
436 let output_ok =
437 crate::bindings::BindingLiquidSdk::fetch_fiat_rates(&*api_that_guard)
438 .await?;
439 Ok(output_ok)
440 })()
441 .await,
442 )
443 }
444 },
445 )
446}
447fn wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(
448 port_: flutter_rust_bridge::for_generated::MessagePort,
449 that: impl CstDecode<
450 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
451 >,
452) {
453 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
454 flutter_rust_bridge::for_generated::TaskInfo {
455 debug_name: "BindingLiquidSdk_fetch_lightning_limits",
456 port: Some(port_),
457 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
458 },
459 move || {
460 let api_that = that.cst_decode();
461 move |context| async move {
462 transform_result_dco::<_, _, crate::error::PaymentError>(
463 (move || async move {
464 let mut api_that_guard = None;
465 let decode_indices_ =
466 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
467 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
468 &api_that, 0, false,
469 )],
470 );
471 for i in decode_indices_ {
472 match i {
473 0 => {
474 api_that_guard =
475 Some(api_that.lockable_decode_async_ref().await)
476 }
477 _ => unreachable!(),
478 }
479 }
480 let api_that_guard = api_that_guard.unwrap();
481 let output_ok = crate::bindings::BindingLiquidSdk::fetch_lightning_limits(
482 &*api_that_guard,
483 )
484 .await?;
485 Ok(output_ok)
486 })()
487 .await,
488 )
489 }
490 },
491 )
492}
493fn wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(
494 port_: flutter_rust_bridge::for_generated::MessagePort,
495 that: impl CstDecode<
496 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
497 >,
498) {
499 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
500 flutter_rust_bridge::for_generated::TaskInfo {
501 debug_name: "BindingLiquidSdk_fetch_onchain_limits",
502 port: Some(port_),
503 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
504 },
505 move || {
506 let api_that = that.cst_decode();
507 move |context| async move {
508 transform_result_dco::<_, _, crate::error::PaymentError>(
509 (move || async move {
510 let mut api_that_guard = None;
511 let decode_indices_ =
512 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
513 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
514 &api_that, 0, false,
515 )],
516 );
517 for i in decode_indices_ {
518 match i {
519 0 => {
520 api_that_guard =
521 Some(api_that.lockable_decode_async_ref().await)
522 }
523 _ => unreachable!(),
524 }
525 }
526 let api_that_guard = api_that_guard.unwrap();
527 let output_ok = crate::bindings::BindingLiquidSdk::fetch_onchain_limits(
528 &*api_that_guard,
529 )
530 .await?;
531 Ok(output_ok)
532 })()
533 .await,
534 )
535 }
536 },
537 )
538}
539fn wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(
540 port_: flutter_rust_bridge::for_generated::MessagePort,
541 that: impl CstDecode<
542 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
543 >,
544 req: impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>,
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_fetch_payment_proposed_fees",
549 port: Some(port_),
550 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
551 },
552 move || {
553 let api_that = that.cst_decode();
554 let api_req = req.cst_decode();
555 move |context| async move {
556 transform_result_dco::<_, _, crate::error::SdkError>(
557 (move || async move {
558 let mut api_that_guard = None;
559 let decode_indices_ =
560 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
561 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
562 &api_that, 0, false,
563 )],
564 );
565 for i in decode_indices_ {
566 match i {
567 0 => {
568 api_that_guard =
569 Some(api_that.lockable_decode_async_ref().await)
570 }
571 _ => unreachable!(),
572 }
573 }
574 let api_that_guard = api_that_guard.unwrap();
575 let output_ok =
576 crate::bindings::BindingLiquidSdk::fetch_payment_proposed_fees(
577 &*api_that_guard,
578 api_req,
579 )
580 .await?;
581 Ok(output_ok)
582 })()
583 .await,
584 )
585 }
586 },
587 )
588}
589fn wire__crate__bindings__BindingLiquidSdk_get_info_impl(
590 port_: flutter_rust_bridge::for_generated::MessagePort,
591 that: impl CstDecode<
592 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
593 >,
594) {
595 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
596 flutter_rust_bridge::for_generated::TaskInfo {
597 debug_name: "BindingLiquidSdk_get_info",
598 port: Some(port_),
599 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
600 },
601 move || {
602 let api_that = that.cst_decode();
603 move |context| async move {
604 transform_result_dco::<_, _, crate::error::SdkError>(
605 (move || async move {
606 let mut api_that_guard = None;
607 let decode_indices_ =
608 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
609 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
610 &api_that, 0, false,
611 )],
612 );
613 for i in decode_indices_ {
614 match i {
615 0 => {
616 api_that_guard =
617 Some(api_that.lockable_decode_async_ref().await)
618 }
619 _ => unreachable!(),
620 }
621 }
622 let api_that_guard = api_that_guard.unwrap();
623 let output_ok =
624 crate::bindings::BindingLiquidSdk::get_info(&*api_that_guard).await?;
625 Ok(output_ok)
626 })()
627 .await,
628 )
629 }
630 },
631 )
632}
633fn wire__crate__bindings__BindingLiquidSdk_get_payment_impl(
634 port_: flutter_rust_bridge::for_generated::MessagePort,
635 that: impl CstDecode<
636 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
637 >,
638 req: impl CstDecode<crate::model::GetPaymentRequest>,
639) {
640 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
641 flutter_rust_bridge::for_generated::TaskInfo {
642 debug_name: "BindingLiquidSdk_get_payment",
643 port: Some(port_),
644 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
645 },
646 move || {
647 let api_that = that.cst_decode();
648 let api_req = req.cst_decode();
649 move |context| async move {
650 transform_result_dco::<_, _, crate::error::PaymentError>(
651 (move || async move {
652 let mut api_that_guard = None;
653 let decode_indices_ =
654 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
655 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
656 &api_that, 0, false,
657 )],
658 );
659 for i in decode_indices_ {
660 match i {
661 0 => {
662 api_that_guard =
663 Some(api_that.lockable_decode_async_ref().await)
664 }
665 _ => unreachable!(),
666 }
667 }
668 let api_that_guard = api_that_guard.unwrap();
669 let output_ok = crate::bindings::BindingLiquidSdk::get_payment(
670 &*api_that_guard,
671 api_req,
672 )
673 .await?;
674 Ok(output_ok)
675 })()
676 .await,
677 )
678 }
679 },
680 )
681}
682fn wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(
683 port_: flutter_rust_bridge::for_generated::MessagePort,
684 that: impl CstDecode<
685 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
686 >,
687) {
688 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
689 flutter_rust_bridge::for_generated::TaskInfo {
690 debug_name: "BindingLiquidSdk_list_fiat_currencies",
691 port: Some(port_),
692 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
693 },
694 move || {
695 let api_that = that.cst_decode();
696 move |context| async move {
697 transform_result_dco::<_, _, crate::error::SdkError>(
698 (move || async move {
699 let mut api_that_guard = None;
700 let decode_indices_ =
701 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
702 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
703 &api_that, 0, false,
704 )],
705 );
706 for i in decode_indices_ {
707 match i {
708 0 => {
709 api_that_guard =
710 Some(api_that.lockable_decode_async_ref().await)
711 }
712 _ => unreachable!(),
713 }
714 }
715 let api_that_guard = api_that_guard.unwrap();
716 let output_ok = crate::bindings::BindingLiquidSdk::list_fiat_currencies(
717 &*api_that_guard,
718 )
719 .await?;
720 Ok(output_ok)
721 })()
722 .await,
723 )
724 }
725 },
726 )
727}
728fn wire__crate__bindings__BindingLiquidSdk_list_payments_impl(
729 port_: flutter_rust_bridge::for_generated::MessagePort,
730 that: impl CstDecode<
731 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
732 >,
733 req: impl CstDecode<crate::model::ListPaymentsRequest>,
734) {
735 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
736 flutter_rust_bridge::for_generated::TaskInfo {
737 debug_name: "BindingLiquidSdk_list_payments",
738 port: Some(port_),
739 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
740 },
741 move || {
742 let api_that = that.cst_decode();
743 let api_req = req.cst_decode();
744 move |context| async move {
745 transform_result_dco::<_, _, crate::error::PaymentError>(
746 (move || async move {
747 let mut api_that_guard = None;
748 let decode_indices_ =
749 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
750 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
751 &api_that, 0, false,
752 )],
753 );
754 for i in decode_indices_ {
755 match i {
756 0 => {
757 api_that_guard =
758 Some(api_that.lockable_decode_async_ref().await)
759 }
760 _ => unreachable!(),
761 }
762 }
763 let api_that_guard = api_that_guard.unwrap();
764 let output_ok = crate::bindings::BindingLiquidSdk::list_payments(
765 &*api_that_guard,
766 api_req,
767 )
768 .await?;
769 Ok(output_ok)
770 })()
771 .await,
772 )
773 }
774 },
775 )
776}
777fn wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(
778 port_: flutter_rust_bridge::for_generated::MessagePort,
779 that: impl CstDecode<
780 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
781 >,
782) {
783 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
784 flutter_rust_bridge::for_generated::TaskInfo {
785 debug_name: "BindingLiquidSdk_list_refundables",
786 port: Some(port_),
787 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
788 },
789 move || {
790 let api_that = that.cst_decode();
791 move |context| async move {
792 transform_result_dco::<_, _, crate::error::SdkError>(
793 (move || async move {
794 let mut api_that_guard = None;
795 let decode_indices_ =
796 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
797 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
798 &api_that, 0, false,
799 )],
800 );
801 for i in decode_indices_ {
802 match i {
803 0 => {
804 api_that_guard =
805 Some(api_that.lockable_decode_async_ref().await)
806 }
807 _ => unreachable!(),
808 }
809 }
810 let api_that_guard = api_that_guard.unwrap();
811 let output_ok =
812 crate::bindings::BindingLiquidSdk::list_refundables(&*api_that_guard)
813 .await?;
814 Ok(output_ok)
815 })()
816 .await,
817 )
818 }
819 },
820 )
821}
822fn wire__crate__bindings__BindingLiquidSdk_lnurl_auth_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_data: impl CstDecode<crate::bindings::LnUrlAuthRequestData>,
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_auth",
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_data = req_data.cst_decode();
838 move |context| async move {
839 transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlAuthError>(
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 = crate::bindings::BindingLiquidSdk::lnurl_auth(
859 &*api_that_guard,
860 api_req_data,
861 )
862 .await?;
863 Ok(output_ok)
864 })()
865 .await,
866 )
867 }
868 },
869 )
870}
871fn wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(
872 port_: flutter_rust_bridge::for_generated::MessagePort,
873 that: impl CstDecode<
874 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
875 >,
876 req: impl CstDecode<crate::model::LnUrlPayRequest>,
877) {
878 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
879 flutter_rust_bridge::for_generated::TaskInfo {
880 debug_name: "BindingLiquidSdk_lnurl_pay",
881 port: Some(port_),
882 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
883 },
884 move || {
885 let api_that = that.cst_decode();
886 let api_req = req.cst_decode();
887 move |context| async move {
888 transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlPayError>(
889 (move || async move {
890 let mut api_that_guard = None;
891 let decode_indices_ =
892 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
893 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
894 &api_that, 0, false,
895 )],
896 );
897 for i in decode_indices_ {
898 match i {
899 0 => {
900 api_that_guard =
901 Some(api_that.lockable_decode_async_ref().await)
902 }
903 _ => unreachable!(),
904 }
905 }
906 let api_that_guard = api_that_guard.unwrap();
907 let output_ok =
908 crate::bindings::BindingLiquidSdk::lnurl_pay(&*api_that_guard, api_req)
909 .await?;
910 Ok(output_ok)
911 })()
912 .await,
913 )
914 }
915 },
916 )
917}
918fn wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(
919 port_: flutter_rust_bridge::for_generated::MessagePort,
920 that: impl CstDecode<
921 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
922 >,
923 req: impl CstDecode<crate::bindings::LnUrlWithdrawRequest>,
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_lnurl_withdraw",
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_req = req.cst_decode();
934 move |context| async move {
935 transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlWithdrawError>(
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 = crate::bindings::BindingLiquidSdk::lnurl_withdraw(
955 &*api_that_guard,
956 api_req,
957 )
958 .await?;
959 Ok(output_ok)
960 })()
961 .await,
962 )
963 }
964 },
965 )
966}
967fn wire__crate__bindings__BindingLiquidSdk_parse_impl(
968 port_: flutter_rust_bridge::for_generated::MessagePort,
969 that: impl CstDecode<
970 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
971 >,
972 input: impl CstDecode<String>,
973) {
974 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
975 flutter_rust_bridge::for_generated::TaskInfo {
976 debug_name: "BindingLiquidSdk_parse",
977 port: Some(port_),
978 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
979 },
980 move || {
981 let api_that = that.cst_decode();
982 let api_input = input.cst_decode();
983 move |context| async move {
984 transform_result_dco::<_, _, crate::error::PaymentError>(
985 (move || async move {
986 let mut api_that_guard = None;
987 let decode_indices_ =
988 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
989 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
990 &api_that, 0, false,
991 )],
992 );
993 for i in decode_indices_ {
994 match i {
995 0 => {
996 api_that_guard =
997 Some(api_that.lockable_decode_async_ref().await)
998 }
999 _ => unreachable!(),
1000 }
1001 }
1002 let api_that_guard = api_that_guard.unwrap();
1003 let output_ok =
1004 crate::bindings::BindingLiquidSdk::parse(&*api_that_guard, api_input)
1005 .await?;
1006 Ok(output_ok)
1007 })()
1008 .await,
1009 )
1010 }
1011 },
1012 )
1013}
1014fn wire__crate__bindings__BindingLiquidSdk_pay_onchain_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::PayOnchainRequest>,
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_pay_onchain",
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::pay_onchain(
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_buy_bitcoin_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::PrepareBuyBitcoinRequest>,
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_buy_bitcoin",
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::error::PaymentError>(
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_buy_bitcoin(
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_lnurl_pay_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::PrepareLnUrlPayRequest>,
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_lnurl_pay",
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::bindings::duplicates::LnUrlPayError>(
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_lnurl_pay(
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_pay_onchain_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::PreparePayOnchainRequest>,
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_pay_onchain",
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_pay_onchain(
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_receive_payment_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::PrepareReceiveRequest>,
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_receive_payment",
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::PaymentError>(
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_receive_payment(
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_refund_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::PrepareRefundRequest>,
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_refund",
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::SdkError>(
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_refund(
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_prepare_send_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::PrepareSendRequest>,
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_prepare_send_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::prepare_send_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_receive_payment_impl(
1358 port_: flutter_rust_bridge::for_generated::MessagePort,
1359 that: impl CstDecode<
1360 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1361 >,
1362 req: impl CstDecode<crate::model::ReceivePaymentRequest>,
1363) {
1364 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1365 flutter_rust_bridge::for_generated::TaskInfo {
1366 debug_name: "BindingLiquidSdk_receive_payment",
1367 port: Some(port_),
1368 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1369 },
1370 move || {
1371 let api_that = that.cst_decode();
1372 let api_req = req.cst_decode();
1373 move |context| async move {
1374 transform_result_dco::<_, _, crate::error::PaymentError>(
1375 (move || async move {
1376 let mut api_that_guard = None;
1377 let decode_indices_ =
1378 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1379 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1380 &api_that, 0, false,
1381 )],
1382 );
1383 for i in decode_indices_ {
1384 match i {
1385 0 => {
1386 api_that_guard =
1387 Some(api_that.lockable_decode_async_ref().await)
1388 }
1389 _ => unreachable!(),
1390 }
1391 }
1392 let api_that_guard = api_that_guard.unwrap();
1393 let output_ok = crate::bindings::BindingLiquidSdk::receive_payment(
1394 &*api_that_guard,
1395 api_req,
1396 )
1397 .await?;
1398 Ok(output_ok)
1399 })()
1400 .await,
1401 )
1402 }
1403 },
1404 )
1405}
1406fn wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(
1407 port_: flutter_rust_bridge::for_generated::MessagePort,
1408 that: impl CstDecode<
1409 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1410 >,
1411) {
1412 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1413 flutter_rust_bridge::for_generated::TaskInfo {
1414 debug_name: "BindingLiquidSdk_recommended_fees",
1415 port: Some(port_),
1416 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1417 },
1418 move || {
1419 let api_that = that.cst_decode();
1420 move |context| async move {
1421 transform_result_dco::<_, _, crate::error::SdkError>(
1422 (move || async move {
1423 let mut api_that_guard = None;
1424 let decode_indices_ =
1425 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1426 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1427 &api_that, 0, false,
1428 )],
1429 );
1430 for i in decode_indices_ {
1431 match i {
1432 0 => {
1433 api_that_guard =
1434 Some(api_that.lockable_decode_async_ref().await)
1435 }
1436 _ => unreachable!(),
1437 }
1438 }
1439 let api_that_guard = api_that_guard.unwrap();
1440 let output_ok =
1441 crate::bindings::BindingLiquidSdk::recommended_fees(&*api_that_guard)
1442 .await?;
1443 Ok(output_ok)
1444 })()
1445 .await,
1446 )
1447 }
1448 },
1449 )
1450}
1451fn wire__crate__bindings__BindingLiquidSdk_refund_impl(
1452 port_: flutter_rust_bridge::for_generated::MessagePort,
1453 that: impl CstDecode<
1454 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1455 >,
1456 req: impl CstDecode<crate::model::RefundRequest>,
1457) {
1458 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1459 flutter_rust_bridge::for_generated::TaskInfo {
1460 debug_name: "BindingLiquidSdk_refund",
1461 port: Some(port_),
1462 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1463 },
1464 move || {
1465 let api_that = that.cst_decode();
1466 let api_req = req.cst_decode();
1467 move |context| async move {
1468 transform_result_dco::<_, _, crate::error::PaymentError>(
1469 (move || async move {
1470 let mut api_that_guard = None;
1471 let decode_indices_ =
1472 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1473 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1474 &api_that, 0, false,
1475 )],
1476 );
1477 for i in decode_indices_ {
1478 match i {
1479 0 => {
1480 api_that_guard =
1481 Some(api_that.lockable_decode_async_ref().await)
1482 }
1483 _ => unreachable!(),
1484 }
1485 }
1486 let api_that_guard = api_that_guard.unwrap();
1487 let output_ok =
1488 crate::bindings::BindingLiquidSdk::refund(&*api_that_guard, api_req)
1489 .await?;
1490 Ok(output_ok)
1491 })()
1492 .await,
1493 )
1494 }
1495 },
1496 )
1497}
1498fn wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(
1499 port_: flutter_rust_bridge::for_generated::MessagePort,
1500 that: impl CstDecode<
1501 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1502 >,
1503 webhook_url: impl CstDecode<String>,
1504) {
1505 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1506 flutter_rust_bridge::for_generated::TaskInfo {
1507 debug_name: "BindingLiquidSdk_register_webhook",
1508 port: Some(port_),
1509 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1510 },
1511 move || {
1512 let api_that = that.cst_decode();
1513 let api_webhook_url = webhook_url.cst_decode();
1514 move |context| async move {
1515 transform_result_dco::<_, _, crate::error::SdkError>(
1516 (move || async move {
1517 let mut api_that_guard = None;
1518 let decode_indices_ =
1519 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1520 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1521 &api_that, 0, false,
1522 )],
1523 );
1524 for i in decode_indices_ {
1525 match i {
1526 0 => {
1527 api_that_guard =
1528 Some(api_that.lockable_decode_async_ref().await)
1529 }
1530 _ => unreachable!(),
1531 }
1532 }
1533 let api_that_guard = api_that_guard.unwrap();
1534 let output_ok = crate::bindings::BindingLiquidSdk::register_webhook(
1535 &*api_that_guard,
1536 api_webhook_url,
1537 )
1538 .await?;
1539 Ok(output_ok)
1540 })()
1541 .await,
1542 )
1543 }
1544 },
1545 )
1546}
1547fn wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(
1548 port_: flutter_rust_bridge::for_generated::MessagePort,
1549 that: impl CstDecode<
1550 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1551 >,
1552) {
1553 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1554 flutter_rust_bridge::for_generated::TaskInfo {
1555 debug_name: "BindingLiquidSdk_rescan_onchain_swaps",
1556 port: Some(port_),
1557 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1558 },
1559 move || {
1560 let api_that = that.cst_decode();
1561 move |context| async move {
1562 transform_result_dco::<_, _, crate::error::SdkError>(
1563 (move || async move {
1564 let mut api_that_guard = None;
1565 let decode_indices_ =
1566 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1567 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1568 &api_that, 0, false,
1569 )],
1570 );
1571 for i in decode_indices_ {
1572 match i {
1573 0 => {
1574 api_that_guard =
1575 Some(api_that.lockable_decode_async_ref().await)
1576 }
1577 _ => unreachable!(),
1578 }
1579 }
1580 let api_that_guard = api_that_guard.unwrap();
1581 let output_ok = crate::bindings::BindingLiquidSdk::rescan_onchain_swaps(
1582 &*api_that_guard,
1583 )
1584 .await?;
1585 Ok(output_ok)
1586 })()
1587 .await,
1588 )
1589 }
1590 },
1591 )
1592}
1593fn wire__crate__bindings__BindingLiquidSdk_restore_impl(
1594 that: impl CstDecode<
1595 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1596 >,
1597 req: impl CstDecode<crate::model::RestoreRequest>,
1598) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1599 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1600 flutter_rust_bridge::for_generated::TaskInfo {
1601 debug_name: "BindingLiquidSdk_restore",
1602 port: None,
1603 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1604 },
1605 move || {
1606 let api_that = that.cst_decode();
1607 let api_req = req.cst_decode();
1608 transform_result_dco::<_, _, crate::error::SdkError>((move || {
1609 let mut api_that_guard = None;
1610 let decode_indices_ =
1611 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
1612 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1613 &api_that, 0, false,
1614 ),
1615 ]);
1616 for i in decode_indices_ {
1617 match i {
1618 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
1619 _ => unreachable!(),
1620 }
1621 }
1622 let api_that_guard = api_that_guard.unwrap();
1623 let output_ok =
1624 crate::bindings::BindingLiquidSdk::restore(&*api_that_guard, api_req)?;
1625 Ok(output_ok)
1626 })())
1627 },
1628 )
1629}
1630fn wire__crate__bindings__BindingLiquidSdk_send_payment_impl(
1631 port_: flutter_rust_bridge::for_generated::MessagePort,
1632 that: impl CstDecode<
1633 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1634 >,
1635 req: impl CstDecode<crate::model::SendPaymentRequest>,
1636) {
1637 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1638 flutter_rust_bridge::for_generated::TaskInfo {
1639 debug_name: "BindingLiquidSdk_send_payment",
1640 port: Some(port_),
1641 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1642 },
1643 move || {
1644 let api_that = that.cst_decode();
1645 let api_req = req.cst_decode();
1646 move |context| async move {
1647 transform_result_dco::<_, _, crate::error::PaymentError>(
1648 (move || async move {
1649 let mut api_that_guard = None;
1650 let decode_indices_ =
1651 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1652 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1653 &api_that, 0, false,
1654 )],
1655 );
1656 for i in decode_indices_ {
1657 match i {
1658 0 => {
1659 api_that_guard =
1660 Some(api_that.lockable_decode_async_ref().await)
1661 }
1662 _ => unreachable!(),
1663 }
1664 }
1665 let api_that_guard = api_that_guard.unwrap();
1666 let output_ok = crate::bindings::BindingLiquidSdk::send_payment(
1667 &*api_that_guard,
1668 api_req,
1669 )
1670 .await?;
1671 Ok(output_ok)
1672 })()
1673 .await,
1674 )
1675 }
1676 },
1677 )
1678}
1679fn wire__crate__bindings__BindingLiquidSdk_sign_message_impl(
1680 that: impl CstDecode<
1681 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1682 >,
1683 req: impl CstDecode<crate::model::SignMessageRequest>,
1684) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1685 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1686 flutter_rust_bridge::for_generated::TaskInfo {
1687 debug_name: "BindingLiquidSdk_sign_message",
1688 port: None,
1689 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1690 },
1691 move || {
1692 let api_that = that.cst_decode();
1693 let api_req = req.cst_decode();
1694 transform_result_dco::<_, _, crate::error::SdkError>((move || {
1695 let mut api_that_guard = None;
1696 let decode_indices_ =
1697 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
1698 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1699 &api_that, 0, false,
1700 ),
1701 ]);
1702 for i in decode_indices_ {
1703 match i {
1704 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
1705 _ => unreachable!(),
1706 }
1707 }
1708 let api_that_guard = api_that_guard.unwrap();
1709 let output_ok =
1710 crate::bindings::BindingLiquidSdk::sign_message(&*api_that_guard, api_req)?;
1711 Ok(output_ok)
1712 })())
1713 },
1714 )
1715}
1716fn wire__crate__bindings__BindingLiquidSdk_sync_impl(
1717 port_: flutter_rust_bridge::for_generated::MessagePort,
1718 that: impl CstDecode<
1719 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1720 >,
1721) {
1722 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1723 flutter_rust_bridge::for_generated::TaskInfo {
1724 debug_name: "BindingLiquidSdk_sync(dart_style=sync)",
1725 port: Some(port_),
1726 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1727 },
1728 move || {
1729 let api_that = that.cst_decode();
1730 move |context| async move {
1731 transform_result_dco::<_, _, crate::error::SdkError>(
1732 (move || async move {
1733 let mut api_that_guard = None;
1734 let decode_indices_ =
1735 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1736 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1737 &api_that, 0, false,
1738 )],
1739 );
1740 for i in decode_indices_ {
1741 match i {
1742 0 => {
1743 api_that_guard =
1744 Some(api_that.lockable_decode_async_ref().await)
1745 }
1746 _ => unreachable!(),
1747 }
1748 }
1749 let api_that_guard = api_that_guard.unwrap();
1750 let output_ok =
1751 crate::bindings::BindingLiquidSdk::sync(&*api_that_guard).await?;
1752 Ok(output_ok)
1753 })()
1754 .await,
1755 )
1756 }
1757 },
1758 )
1759}
1760fn wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(
1761 port_: flutter_rust_bridge::for_generated::MessagePort,
1762 that: impl CstDecode<
1763 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1764 >,
1765) {
1766 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1767 flutter_rust_bridge::for_generated::TaskInfo {
1768 debug_name: "BindingLiquidSdk_unregister_webhook",
1769 port: Some(port_),
1770 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1771 },
1772 move || {
1773 let api_that = that.cst_decode();
1774 move |context| async move {
1775 transform_result_dco::<_, _, crate::error::SdkError>(
1776 (move || async move {
1777 let mut api_that_guard = None;
1778 let decode_indices_ =
1779 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1780 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1781 &api_that, 0, false,
1782 )],
1783 );
1784 for i in decode_indices_ {
1785 match i {
1786 0 => {
1787 api_that_guard =
1788 Some(api_that.lockable_decode_async_ref().await)
1789 }
1790 _ => unreachable!(),
1791 }
1792 }
1793 let api_that_guard = api_that_guard.unwrap();
1794 let output_ok =
1795 crate::bindings::BindingLiquidSdk::unregister_webhook(&*api_that_guard)
1796 .await?;
1797 Ok(output_ok)
1798 })()
1799 .await,
1800 )
1801 }
1802 },
1803 )
1804}
1805fn wire__crate__bindings__binding_event_listener_on_event_impl(
1806 port_: flutter_rust_bridge::for_generated::MessagePort,
1807 that: impl CstDecode<crate::bindings::BindingEventListener>,
1808 e: impl CstDecode<crate::model::SdkEvent>,
1809) {
1810 FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
1811 flutter_rust_bridge::for_generated::TaskInfo {
1812 debug_name: "binding_event_listener_on_event",
1813 port: Some(port_),
1814 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1815 },
1816 move || {
1817 let api_that = that.cst_decode();
1818 let api_e = e.cst_decode();
1819 move |context| {
1820 transform_result_dco::<_, _, ()>((move || {
1821 let output_ok = Result::<_, ()>::Ok({
1822 crate::bindings::BindingEventListener::on_event(&api_that, api_e);
1823 })?;
1824 Ok(output_ok)
1825 })())
1826 }
1827 },
1828 )
1829}
1830fn wire__crate__bindings__breez_log_stream_impl(
1831 port_: flutter_rust_bridge::for_generated::MessagePort,
1832 s: impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>,
1833) {
1834 FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
1835 flutter_rust_bridge::for_generated::TaskInfo {
1836 debug_name: "breez_log_stream",
1837 port: Some(port_),
1838 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1839 },
1840 move || {
1841 let api_s = s.cst_decode();
1842 move |context| {
1843 transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
1844 (move || {
1845 let output_ok = crate::bindings::breez_log_stream(api_s)?;
1846 Ok(output_ok)
1847 })(),
1848 )
1849 }
1850 },
1851 )
1852}
1853fn wire__crate__bindings__connect_impl(
1854 port_: flutter_rust_bridge::for_generated::MessagePort,
1855 req: impl CstDecode<crate::model::ConnectRequest>,
1856) {
1857 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1858 flutter_rust_bridge::for_generated::TaskInfo {
1859 debug_name: "connect",
1860 port: Some(port_),
1861 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1862 },
1863 move || {
1864 let api_req = req.cst_decode();
1865 move |context| async move {
1866 transform_result_dco::<_, _, crate::error::SdkError>(
1867 (move || async move {
1868 let output_ok = crate::bindings::connect(api_req).await?;
1869 Ok(output_ok)
1870 })()
1871 .await,
1872 )
1873 }
1874 },
1875 )
1876}
1877fn wire__crate__bindings__default_config_impl(
1878 network: impl CstDecode<crate::model::LiquidNetwork>,
1879 breez_api_key: impl CstDecode<Option<String>>,
1880) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1881 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1882 flutter_rust_bridge::for_generated::TaskInfo {
1883 debug_name: "default_config",
1884 port: None,
1885 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1886 },
1887 move || {
1888 let api_network = network.cst_decode();
1889 let api_breez_api_key = breez_api_key.cst_decode();
1890 transform_result_dco::<_, _, crate::error::SdkError>((move || {
1891 let output_ok = crate::bindings::default_config(api_network, api_breez_api_key)?;
1892 Ok(output_ok)
1893 })())
1894 },
1895 )
1896}
1897fn wire__crate__bindings__parse_invoice_impl(
1898 input: impl CstDecode<String>,
1899) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1900 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1901 flutter_rust_bridge::for_generated::TaskInfo {
1902 debug_name: "parse_invoice",
1903 port: None,
1904 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1905 },
1906 move || {
1907 let api_input = input.cst_decode();
1908 transform_result_dco::<_, _, crate::error::PaymentError>((move || {
1909 let output_ok = crate::bindings::parse_invoice(api_input)?;
1910 Ok(output_ok)
1911 })())
1912 },
1913 )
1914}
1915
1916#[allow(clippy::unnecessary_literal_unwrap)]
1919const _: fn() = || {
1920 {
1921 let AesSuccessActionData = None::<crate::bindings::AesSuccessActionData>.unwrap();
1922 let _: String = AesSuccessActionData.description;
1923 let _: String = AesSuccessActionData.ciphertext;
1924 let _: String = AesSuccessActionData.iv;
1925 }
1926 {
1927 let AesSuccessActionDataDecrypted =
1928 None::<crate::bindings::AesSuccessActionDataDecrypted>.unwrap();
1929 let _: String = AesSuccessActionDataDecrypted.description;
1930 let _: String = AesSuccessActionDataDecrypted.plaintext;
1931 }
1932 match None::<crate::bindings::AesSuccessActionDataResult>.unwrap() {
1933 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
1934 let _: crate::bindings::AesSuccessActionDataDecrypted = data;
1935 }
1936 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
1937 let _: String = reason;
1938 }
1939 }
1940 match None::<crate::bindings::Amount>.unwrap() {
1941 crate::bindings::Amount::Bitcoin { amount_msat } => {
1942 let _: u64 = amount_msat;
1943 }
1944 crate::bindings::Amount::Currency {
1945 iso4217_code,
1946 fractional_amount,
1947 } => {
1948 let _: String = iso4217_code;
1949 let _: u64 = fractional_amount;
1950 }
1951 }
1952 {
1953 let BitcoinAddressData = None::<crate::bindings::BitcoinAddressData>.unwrap();
1954 let _: String = BitcoinAddressData.address;
1955 let _: crate::bindings::Network = BitcoinAddressData.network;
1956 let _: Option<u64> = BitcoinAddressData.amount_sat;
1957 let _: Option<String> = BitcoinAddressData.label;
1958 let _: Option<String> = BitcoinAddressData.message;
1959 }
1960 {
1961 let CurrencyInfo = None::<crate::bindings::CurrencyInfo>.unwrap();
1962 let _: String = CurrencyInfo.name;
1963 let _: u32 = CurrencyInfo.fraction_size;
1964 let _: Option<u32> = CurrencyInfo.spacing;
1965 let _: Option<crate::bindings::Symbol> = CurrencyInfo.symbol;
1966 let _: Option<crate::bindings::Symbol> = CurrencyInfo.uniq_symbol;
1967 let _: Vec<crate::bindings::LocalizedName> = CurrencyInfo.localized_name;
1968 let _: Vec<crate::bindings::LocaleOverrides> = CurrencyInfo.locale_overrides;
1969 }
1970 {
1971 let ExternalInputParser = None::<crate::bindings::ExternalInputParser>.unwrap();
1972 let _: String = ExternalInputParser.provider_id;
1973 let _: String = ExternalInputParser.input_regex;
1974 let _: String = ExternalInputParser.parser_url;
1975 }
1976 {
1977 let FiatCurrency = None::<crate::bindings::FiatCurrency>.unwrap();
1978 let _: String = FiatCurrency.id;
1979 let _: crate::bindings::CurrencyInfo = FiatCurrency.info;
1980 }
1981 match None::<crate::bindings::InputType>.unwrap() {
1982 crate::bindings::InputType::BitcoinAddress { address } => {
1983 let _: crate::bindings::BitcoinAddressData = address;
1984 }
1985 crate::bindings::InputType::LiquidAddress { address } => {
1986 let _: crate::bindings::LiquidAddressData = address;
1987 }
1988 crate::bindings::InputType::Bolt11 { invoice } => {
1989 let _: crate::bindings::LNInvoice = invoice;
1990 }
1991 crate::bindings::InputType::Bolt12Offer {
1992 offer,
1993 bip353_address,
1994 } => {
1995 let _: crate::bindings::LNOffer = offer;
1996 let _: Option<String> = bip353_address;
1997 }
1998 crate::bindings::InputType::NodeId { node_id } => {
1999 let _: String = node_id;
2000 }
2001 crate::bindings::InputType::Url { url } => {
2002 let _: String = url;
2003 }
2004 crate::bindings::InputType::LnUrlPay {
2005 data,
2006 bip353_address,
2007 } => {
2008 let _: crate::bindings::LnUrlPayRequestData = data;
2009 let _: Option<String> = bip353_address;
2010 }
2011 crate::bindings::InputType::LnUrlWithdraw { data } => {
2012 let _: crate::bindings::LnUrlWithdrawRequestData = data;
2013 }
2014 crate::bindings::InputType::LnUrlAuth { data } => {
2015 let _: crate::bindings::LnUrlAuthRequestData = data;
2016 }
2017 crate::bindings::InputType::LnUrlError { data } => {
2018 let _: crate::bindings::LnUrlErrorData = data;
2019 }
2020 }
2021 {
2022 let LiquidAddressData = None::<crate::bindings::LiquidAddressData>.unwrap();
2023 let _: String = LiquidAddressData.address;
2024 let _: crate::bindings::Network = LiquidAddressData.network;
2025 let _: Option<String> = LiquidAddressData.asset_id;
2026 let _: Option<f64> = LiquidAddressData.amount;
2027 let _: Option<u64> = LiquidAddressData.amount_sat;
2028 let _: Option<String> = LiquidAddressData.label;
2029 let _: Option<String> = LiquidAddressData.message;
2030 }
2031 {
2032 let LNInvoice = None::<crate::bindings::LNInvoice>.unwrap();
2033 let _: String = LNInvoice.bolt11;
2034 let _: crate::bindings::Network = LNInvoice.network;
2035 let _: String = LNInvoice.payee_pubkey;
2036 let _: String = LNInvoice.payment_hash;
2037 let _: Option<String> = LNInvoice.description;
2038 let _: Option<String> = LNInvoice.description_hash;
2039 let _: Option<u64> = LNInvoice.amount_msat;
2040 let _: u64 = LNInvoice.timestamp;
2041 let _: u64 = LNInvoice.expiry;
2042 let _: Vec<crate::bindings::RouteHint> = LNInvoice.routing_hints;
2043 let _: Vec<u8> = LNInvoice.payment_secret;
2044 let _: u64 = LNInvoice.min_final_cltv_expiry_delta;
2045 }
2046 {
2047 let LNOffer = None::<crate::bindings::LNOffer>.unwrap();
2048 let _: String = LNOffer.offer;
2049 let _: Vec<String> = LNOffer.chains;
2050 let _: Option<crate::bindings::Amount> = LNOffer.min_amount;
2051 let _: Option<String> = LNOffer.description;
2052 let _: Option<u64> = LNOffer.absolute_expiry;
2053 let _: Option<String> = LNOffer.issuer;
2054 let _: Option<String> = LNOffer.signing_pubkey;
2055 let _: Vec<crate::bindings::LnOfferBlindedPath> = LNOffer.paths;
2056 }
2057 {
2058 let LnOfferBlindedPath = None::<crate::bindings::LnOfferBlindedPath>.unwrap();
2059 let _: Vec<String> = LnOfferBlindedPath.blinded_hops;
2060 }
2061 {
2062 let LnUrlAuthRequestData = None::<crate::bindings::LnUrlAuthRequestData>.unwrap();
2063 let _: String = LnUrlAuthRequestData.k1;
2064 let _: Option<String> = LnUrlAuthRequestData.action;
2065 let _: String = LnUrlAuthRequestData.domain;
2066 let _: String = LnUrlAuthRequestData.url;
2067 }
2068 {
2069 let LnUrlErrorData = None::<crate::bindings::LnUrlErrorData>.unwrap();
2070 let _: String = LnUrlErrorData.reason;
2071 }
2072 {
2073 let LnUrlPayErrorData = None::<crate::bindings::LnUrlPayErrorData>.unwrap();
2074 let _: String = LnUrlPayErrorData.payment_hash;
2075 let _: String = LnUrlPayErrorData.reason;
2076 }
2077 {
2078 let LnUrlPayRequestData = None::<crate::bindings::LnUrlPayRequestData>.unwrap();
2079 let _: String = LnUrlPayRequestData.callback;
2080 let _: u64 = LnUrlPayRequestData.min_sendable;
2081 let _: u64 = LnUrlPayRequestData.max_sendable;
2082 let _: String = LnUrlPayRequestData.metadata_str;
2083 let _: u16 = LnUrlPayRequestData.comment_allowed;
2084 let _: String = LnUrlPayRequestData.domain;
2085 let _: bool = LnUrlPayRequestData.allows_nostr;
2086 let _: Option<String> = LnUrlPayRequestData.nostr_pubkey;
2087 let _: Option<String> = LnUrlPayRequestData.ln_address;
2088 }
2089 {
2090 let LnUrlWithdrawRequest = None::<crate::bindings::LnUrlWithdrawRequest>.unwrap();
2091 let _: crate::bindings::LnUrlWithdrawRequestData = LnUrlWithdrawRequest.data;
2092 let _: u64 = LnUrlWithdrawRequest.amount_msat;
2093 let _: Option<String> = LnUrlWithdrawRequest.description;
2094 }
2095 {
2096 let LnUrlWithdrawRequestData = None::<crate::bindings::LnUrlWithdrawRequestData>.unwrap();
2097 let _: String = LnUrlWithdrawRequestData.callback;
2098 let _: String = LnUrlWithdrawRequestData.k1;
2099 let _: String = LnUrlWithdrawRequestData.default_description;
2100 let _: u64 = LnUrlWithdrawRequestData.min_withdrawable;
2101 let _: u64 = LnUrlWithdrawRequestData.max_withdrawable;
2102 }
2103 {
2104 let LocaleOverrides = None::<crate::bindings::LocaleOverrides>.unwrap();
2105 let _: String = LocaleOverrides.locale;
2106 let _: Option<u32> = LocaleOverrides.spacing;
2107 let _: crate::bindings::Symbol = LocaleOverrides.symbol;
2108 }
2109 {
2110 let LocalizedName = None::<crate::bindings::LocalizedName>.unwrap();
2111 let _: String = LocalizedName.locale;
2112 let _: String = LocalizedName.name;
2113 }
2114 {
2115 let MessageSuccessActionData = None::<crate::bindings::MessageSuccessActionData>.unwrap();
2116 let _: String = MessageSuccessActionData.message;
2117 }
2118 {
2119 let Rate = None::<crate::bindings::Rate>.unwrap();
2120 let _: String = Rate.coin;
2121 let _: f64 = Rate.value;
2122 }
2123 {
2124 let RouteHint = None::<crate::bindings::RouteHint>.unwrap();
2125 let _: Vec<crate::bindings::RouteHintHop> = RouteHint.hops;
2126 }
2127 {
2128 let RouteHintHop = None::<crate::bindings::RouteHintHop>.unwrap();
2129 let _: String = RouteHintHop.src_node_id;
2130 let _: String = RouteHintHop.short_channel_id;
2131 let _: u32 = RouteHintHop.fees_base_msat;
2132 let _: u32 = RouteHintHop.fees_proportional_millionths;
2133 let _: u64 = RouteHintHop.cltv_expiry_delta;
2134 let _: Option<u64> = RouteHintHop.htlc_minimum_msat;
2135 let _: Option<u64> = RouteHintHop.htlc_maximum_msat;
2136 }
2137 match None::<crate::bindings::SuccessAction>.unwrap() {
2138 crate::bindings::SuccessAction::Aes { data } => {
2139 let _: crate::bindings::AesSuccessActionData = data;
2140 }
2141 crate::bindings::SuccessAction::Message { data } => {
2142 let _: crate::bindings::MessageSuccessActionData = data;
2143 }
2144 crate::bindings::SuccessAction::Url { data } => {
2145 let _: crate::bindings::UrlSuccessActionData = data;
2146 }
2147 }
2148 match None::<crate::bindings::SuccessActionProcessed>.unwrap() {
2149 crate::bindings::SuccessActionProcessed::Aes { result } => {
2150 let _: crate::bindings::AesSuccessActionDataResult = result;
2151 }
2152 crate::bindings::SuccessActionProcessed::Message { data } => {
2153 let _: crate::bindings::MessageSuccessActionData = data;
2154 }
2155 crate::bindings::SuccessActionProcessed::Url { data } => {
2156 let _: crate::bindings::UrlSuccessActionData = data;
2157 }
2158 }
2159 {
2160 let Symbol = None::<crate::bindings::Symbol>.unwrap();
2161 let _: Option<String> = Symbol.grapheme;
2162 let _: Option<String> = Symbol.template;
2163 let _: Option<bool> = Symbol.rtl;
2164 let _: Option<u32> = Symbol.position;
2165 }
2166 {
2167 let UrlSuccessActionData = None::<crate::bindings::UrlSuccessActionData>.unwrap();
2168 let _: String = UrlSuccessActionData.description;
2169 let _: String = UrlSuccessActionData.url;
2170 let _: bool = UrlSuccessActionData.matches_callback_domain;
2171 }
2172};
2173
2174impl CstDecode<bool> for bool {
2177 fn cst_decode(self) -> bool {
2179 self
2180 }
2181}
2182impl CstDecode<crate::model::BuyBitcoinProvider> for i32 {
2183 fn cst_decode(self) -> crate::model::BuyBitcoinProvider {
2185 match self {
2186 0 => crate::model::BuyBitcoinProvider::Moonpay,
2187 _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", self),
2188 }
2189 }
2190}
2191impl CstDecode<f64> for f64 {
2192 fn cst_decode(self) -> f64 {
2194 self
2195 }
2196}
2197impl CstDecode<i32> for i32 {
2198 fn cst_decode(self) -> i32 {
2200 self
2201 }
2202}
2203impl CstDecode<i64> for i64 {
2204 fn cst_decode(self) -> i64 {
2206 self
2207 }
2208}
2209impl CstDecode<crate::model::LiquidNetwork> for i32 {
2210 fn cst_decode(self) -> crate::model::LiquidNetwork {
2212 match self {
2213 0 => crate::model::LiquidNetwork::Mainnet,
2214 1 => crate::model::LiquidNetwork::Testnet,
2215 2 => crate::model::LiquidNetwork::Regtest,
2216 _ => unreachable!("Invalid variant for LiquidNetwork: {}", self),
2217 }
2218 }
2219}
2220impl CstDecode<crate::bindings::Network> for i32 {
2221 fn cst_decode(self) -> crate::bindings::Network {
2223 match self {
2224 0 => crate::bindings::Network::Bitcoin,
2225 1 => crate::bindings::Network::Testnet,
2226 2 => crate::bindings::Network::Signet,
2227 3 => crate::bindings::Network::Regtest,
2228 _ => unreachable!("Invalid variant for Network: {}", self),
2229 }
2230 }
2231}
2232impl CstDecode<crate::model::PaymentMethod> for i32 {
2233 fn cst_decode(self) -> crate::model::PaymentMethod {
2235 match self {
2236 0 => crate::model::PaymentMethod::Lightning,
2237 1 => crate::model::PaymentMethod::Bolt11Invoice,
2238 2 => crate::model::PaymentMethod::Bolt12Offer,
2239 3 => crate::model::PaymentMethod::BitcoinAddress,
2240 4 => crate::model::PaymentMethod::LiquidAddress,
2241 _ => unreachable!("Invalid variant for PaymentMethod: {}", self),
2242 }
2243 }
2244}
2245impl CstDecode<crate::model::PaymentState> for i32 {
2246 fn cst_decode(self) -> crate::model::PaymentState {
2248 match self {
2249 0 => crate::model::PaymentState::Created,
2250 1 => crate::model::PaymentState::Pending,
2251 2 => crate::model::PaymentState::Complete,
2252 3 => crate::model::PaymentState::Failed,
2253 4 => crate::model::PaymentState::TimedOut,
2254 5 => crate::model::PaymentState::Refundable,
2255 6 => crate::model::PaymentState::RefundPending,
2256 7 => crate::model::PaymentState::WaitingFeeAcceptance,
2257 _ => unreachable!("Invalid variant for PaymentState: {}", self),
2258 }
2259 }
2260}
2261impl CstDecode<crate::model::PaymentType> for i32 {
2262 fn cst_decode(self) -> crate::model::PaymentType {
2264 match self {
2265 0 => crate::model::PaymentType::Receive,
2266 1 => crate::model::PaymentType::Send,
2267 _ => unreachable!("Invalid variant for PaymentType: {}", self),
2268 }
2269 }
2270}
2271impl CstDecode<u16> for u16 {
2272 fn cst_decode(self) -> u16 {
2274 self
2275 }
2276}
2277impl CstDecode<u32> for u32 {
2278 fn cst_decode(self) -> u32 {
2280 self
2281 }
2282}
2283impl CstDecode<u64> for u64 {
2284 fn cst_decode(self) -> u64 {
2286 self
2287 }
2288}
2289impl CstDecode<u8> for u8 {
2290 fn cst_decode(self) -> u8 {
2292 self
2293 }
2294}
2295impl CstDecode<usize> for usize {
2296 fn cst_decode(self) -> usize {
2298 self
2299 }
2300}
2301impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
2302 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2304 let mut inner = <String>::sse_decode(deserializer);
2305 return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
2306 }
2307}
2308
2309impl SseDecode for BindingLiquidSdk {
2310 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2312 let mut inner = <RustOpaqueNom<
2313 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
2314 >>::sse_decode(deserializer);
2315 return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
2316 }
2317}
2318
2319impl SseDecode
2320 for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
2321{
2322 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2324 let mut inner = <usize>::sse_decode(deserializer);
2325 return unsafe { decode_rust_opaque_nom(inner) };
2326 }
2327}
2328
2329impl SseDecode
2330 for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
2331{
2332 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2334 let mut inner = <String>::sse_decode(deserializer);
2335 return StreamSink::deserialize(inner);
2336 }
2337}
2338
2339impl SseDecode
2340 for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
2341{
2342 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2344 let mut inner = <String>::sse_decode(deserializer);
2345 return StreamSink::deserialize(inner);
2346 }
2347}
2348
2349impl SseDecode for String {
2350 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2352 let mut inner = <Vec<u8>>::sse_decode(deserializer);
2353 return String::from_utf8(inner).unwrap();
2354 }
2355}
2356
2357impl SseDecode for crate::model::AcceptPaymentProposedFeesRequest {
2358 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2360 let mut var_response =
2361 <crate::model::FetchPaymentProposedFeesResponse>::sse_decode(deserializer);
2362 return crate::model::AcceptPaymentProposedFeesRequest {
2363 response: var_response,
2364 };
2365 }
2366}
2367
2368impl SseDecode for crate::bindings::AesSuccessActionData {
2369 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2371 let mut var_description = <String>::sse_decode(deserializer);
2372 let mut var_ciphertext = <String>::sse_decode(deserializer);
2373 let mut var_iv = <String>::sse_decode(deserializer);
2374 return crate::bindings::AesSuccessActionData {
2375 description: var_description,
2376 ciphertext: var_ciphertext,
2377 iv: var_iv,
2378 };
2379 }
2380}
2381
2382impl SseDecode for crate::bindings::AesSuccessActionDataDecrypted {
2383 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2385 let mut var_description = <String>::sse_decode(deserializer);
2386 let mut var_plaintext = <String>::sse_decode(deserializer);
2387 return crate::bindings::AesSuccessActionDataDecrypted {
2388 description: var_description,
2389 plaintext: var_plaintext,
2390 };
2391 }
2392}
2393
2394impl SseDecode for crate::bindings::AesSuccessActionDataResult {
2395 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2397 let mut tag_ = <i32>::sse_decode(deserializer);
2398 match tag_ {
2399 0 => {
2400 let mut var_data =
2401 <crate::bindings::AesSuccessActionDataDecrypted>::sse_decode(deserializer);
2402 return crate::bindings::AesSuccessActionDataResult::Decrypted { data: var_data };
2403 }
2404 1 => {
2405 let mut var_reason = <String>::sse_decode(deserializer);
2406 return crate::bindings::AesSuccessActionDataResult::ErrorStatus {
2407 reason: var_reason,
2408 };
2409 }
2410 _ => {
2411 unimplemented!("");
2412 }
2413 }
2414 }
2415}
2416
2417impl SseDecode for crate::bindings::Amount {
2418 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2420 let mut tag_ = <i32>::sse_decode(deserializer);
2421 match tag_ {
2422 0 => {
2423 let mut var_amountMsat = <u64>::sse_decode(deserializer);
2424 return crate::bindings::Amount::Bitcoin {
2425 amount_msat: var_amountMsat,
2426 };
2427 }
2428 1 => {
2429 let mut var_iso4217Code = <String>::sse_decode(deserializer);
2430 let mut var_fractionalAmount = <u64>::sse_decode(deserializer);
2431 return crate::bindings::Amount::Currency {
2432 iso4217_code: var_iso4217Code,
2433 fractional_amount: var_fractionalAmount,
2434 };
2435 }
2436 _ => {
2437 unimplemented!("");
2438 }
2439 }
2440 }
2441}
2442
2443impl SseDecode for crate::model::AssetBalance {
2444 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2446 let mut var_assetId = <String>::sse_decode(deserializer);
2447 let mut var_balanceSat = <u64>::sse_decode(deserializer);
2448 let mut var_name = <Option<String>>::sse_decode(deserializer);
2449 let mut var_ticker = <Option<String>>::sse_decode(deserializer);
2450 let mut var_balance = <Option<f64>>::sse_decode(deserializer);
2451 return crate::model::AssetBalance {
2452 asset_id: var_assetId,
2453 balance_sat: var_balanceSat,
2454 name: var_name,
2455 ticker: var_ticker,
2456 balance: var_balance,
2457 };
2458 }
2459}
2460
2461impl SseDecode for crate::model::AssetInfo {
2462 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2464 let mut var_name = <String>::sse_decode(deserializer);
2465 let mut var_ticker = <String>::sse_decode(deserializer);
2466 let mut var_amount = <f64>::sse_decode(deserializer);
2467 let mut var_fees = <Option<f64>>::sse_decode(deserializer);
2468 return crate::model::AssetInfo {
2469 name: var_name,
2470 ticker: var_ticker,
2471 amount: var_amount,
2472 fees: var_fees,
2473 };
2474 }
2475}
2476
2477impl SseDecode for crate::model::AssetMetadata {
2478 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2480 let mut var_assetId = <String>::sse_decode(deserializer);
2481 let mut var_name = <String>::sse_decode(deserializer);
2482 let mut var_ticker = <String>::sse_decode(deserializer);
2483 let mut var_precision = <u8>::sse_decode(deserializer);
2484 let mut var_fiatId = <Option<String>>::sse_decode(deserializer);
2485 return crate::model::AssetMetadata {
2486 asset_id: var_assetId,
2487 name: var_name,
2488 ticker: var_ticker,
2489 precision: var_precision,
2490 fiat_id: var_fiatId,
2491 };
2492 }
2493}
2494
2495impl SseDecode for crate::model::BackupRequest {
2496 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2498 let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
2499 return crate::model::BackupRequest {
2500 backup_path: var_backupPath,
2501 };
2502 }
2503}
2504
2505impl SseDecode for crate::bindings::BindingEventListener {
2506 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2508 let mut var_stream = <StreamSink<
2509 crate::model::SdkEvent,
2510 flutter_rust_bridge::for_generated::DcoCodec,
2511 >>::sse_decode(deserializer);
2512 return crate::bindings::BindingEventListener { stream: var_stream };
2513 }
2514}
2515
2516impl SseDecode for crate::bindings::BitcoinAddressData {
2517 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2519 let mut var_address = <String>::sse_decode(deserializer);
2520 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2521 let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2522 let mut var_label = <Option<String>>::sse_decode(deserializer);
2523 let mut var_message = <Option<String>>::sse_decode(deserializer);
2524 return crate::bindings::BitcoinAddressData {
2525 address: var_address,
2526 network: var_network,
2527 amount_sat: var_amountSat,
2528 label: var_label,
2529 message: var_message,
2530 };
2531 }
2532}
2533
2534impl SseDecode for crate::model::BlockchainExplorer {
2535 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2537 let mut tag_ = <i32>::sse_decode(deserializer);
2538 match tag_ {
2539 0 => {
2540 let mut var_url = <String>::sse_decode(deserializer);
2541 return crate::model::BlockchainExplorer::Electrum { url: var_url };
2542 }
2543 1 => {
2544 let mut var_url = <String>::sse_decode(deserializer);
2545 let mut var_useWaterfalls = <bool>::sse_decode(deserializer);
2546 return crate::model::BlockchainExplorer::Esplora {
2547 url: var_url,
2548 use_waterfalls: var_useWaterfalls,
2549 };
2550 }
2551 _ => {
2552 unimplemented!("");
2553 }
2554 }
2555 }
2556}
2557
2558impl SseDecode for crate::model::BlockchainInfo {
2559 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2561 let mut var_liquidTip = <u32>::sse_decode(deserializer);
2562 let mut var_bitcoinTip = <u32>::sse_decode(deserializer);
2563 return crate::model::BlockchainInfo {
2564 liquid_tip: var_liquidTip,
2565 bitcoin_tip: var_bitcoinTip,
2566 };
2567 }
2568}
2569
2570impl SseDecode for bool {
2571 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2573 deserializer.cursor.read_u8().unwrap() != 0
2574 }
2575}
2576
2577impl SseDecode for crate::model::BuyBitcoinProvider {
2578 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2580 let mut inner = <i32>::sse_decode(deserializer);
2581 return match inner {
2582 0 => crate::model::BuyBitcoinProvider::Moonpay,
2583 _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", inner),
2584 };
2585 }
2586}
2587
2588impl SseDecode for crate::model::BuyBitcoinRequest {
2589 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2591 let mut var_prepareResponse =
2592 <crate::model::PrepareBuyBitcoinResponse>::sse_decode(deserializer);
2593 let mut var_redirectUrl = <Option<String>>::sse_decode(deserializer);
2594 return crate::model::BuyBitcoinRequest {
2595 prepare_response: var_prepareResponse,
2596 redirect_url: var_redirectUrl,
2597 };
2598 }
2599}
2600
2601impl SseDecode for crate::model::CheckMessageRequest {
2602 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2604 let mut var_message = <String>::sse_decode(deserializer);
2605 let mut var_pubkey = <String>::sse_decode(deserializer);
2606 let mut var_signature = <String>::sse_decode(deserializer);
2607 return crate::model::CheckMessageRequest {
2608 message: var_message,
2609 pubkey: var_pubkey,
2610 signature: var_signature,
2611 };
2612 }
2613}
2614
2615impl SseDecode for crate::model::CheckMessageResponse {
2616 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2618 let mut var_isValid = <bool>::sse_decode(deserializer);
2619 return crate::model::CheckMessageResponse {
2620 is_valid: var_isValid,
2621 };
2622 }
2623}
2624
2625impl SseDecode for crate::model::Config {
2626 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2628 let mut var_liquidExplorer = <crate::model::BlockchainExplorer>::sse_decode(deserializer);
2629 let mut var_bitcoinExplorer = <crate::model::BlockchainExplorer>::sse_decode(deserializer);
2630 let mut var_workingDir = <String>::sse_decode(deserializer);
2631 let mut var_network = <crate::model::LiquidNetwork>::sse_decode(deserializer);
2632 let mut var_paymentTimeoutSec = <u64>::sse_decode(deserializer);
2633 let mut var_syncServiceUrl = <Option<String>>::sse_decode(deserializer);
2634 let mut var_zeroConfMaxAmountSat = <Option<u64>>::sse_decode(deserializer);
2635 let mut var_breezApiKey = <Option<String>>::sse_decode(deserializer);
2636 let mut var_externalInputParsers =
2637 <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_decode(deserializer);
2638 let mut var_useDefaultExternalInputParsers = <bool>::sse_decode(deserializer);
2639 let mut var_onchainFeeRateLeewaySat = <Option<u64>>::sse_decode(deserializer);
2640 let mut var_assetMetadata =
2641 <Option<Vec<crate::model::AssetMetadata>>>::sse_decode(deserializer);
2642 let mut var_sideswapApiKey = <Option<String>>::sse_decode(deserializer);
2643 let mut var_useMagicRoutingHints = <bool>::sse_decode(deserializer);
2644 return crate::model::Config {
2645 liquid_explorer: var_liquidExplorer,
2646 bitcoin_explorer: var_bitcoinExplorer,
2647 working_dir: var_workingDir,
2648 network: var_network,
2649 payment_timeout_sec: var_paymentTimeoutSec,
2650 sync_service_url: var_syncServiceUrl,
2651 zero_conf_max_amount_sat: var_zeroConfMaxAmountSat,
2652 breez_api_key: var_breezApiKey,
2653 external_input_parsers: var_externalInputParsers,
2654 use_default_external_input_parsers: var_useDefaultExternalInputParsers,
2655 onchain_fee_rate_leeway_sat: var_onchainFeeRateLeewaySat,
2656 asset_metadata: var_assetMetadata,
2657 sideswap_api_key: var_sideswapApiKey,
2658 use_magic_routing_hints: var_useMagicRoutingHints,
2659 };
2660 }
2661}
2662
2663impl SseDecode for crate::model::ConnectRequest {
2664 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2666 let mut var_config = <crate::model::Config>::sse_decode(deserializer);
2667 let mut var_mnemonic = <Option<String>>::sse_decode(deserializer);
2668 let mut var_passphrase = <Option<String>>::sse_decode(deserializer);
2669 let mut var_seed = <Option<Vec<u8>>>::sse_decode(deserializer);
2670 return crate::model::ConnectRequest {
2671 config: var_config,
2672 mnemonic: var_mnemonic,
2673 passphrase: var_passphrase,
2674 seed: var_seed,
2675 };
2676 }
2677}
2678
2679impl SseDecode for crate::model::CreateBolt12InvoiceRequest {
2680 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2682 let mut var_offer = <String>::sse_decode(deserializer);
2683 let mut var_invoiceRequest = <String>::sse_decode(deserializer);
2684 return crate::model::CreateBolt12InvoiceRequest {
2685 offer: var_offer,
2686 invoice_request: var_invoiceRequest,
2687 };
2688 }
2689}
2690
2691impl SseDecode for crate::model::CreateBolt12InvoiceResponse {
2692 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2694 let mut var_invoice = <String>::sse_decode(deserializer);
2695 return crate::model::CreateBolt12InvoiceResponse {
2696 invoice: var_invoice,
2697 };
2698 }
2699}
2700
2701impl SseDecode for crate::bindings::CurrencyInfo {
2702 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2704 let mut var_name = <String>::sse_decode(deserializer);
2705 let mut var_fractionSize = <u32>::sse_decode(deserializer);
2706 let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
2707 let mut var_symbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2708 let mut var_uniqSymbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2709 let mut var_localizedName = <Vec<crate::bindings::LocalizedName>>::sse_decode(deserializer);
2710 let mut var_localeOverrides =
2711 <Vec<crate::bindings::LocaleOverrides>>::sse_decode(deserializer);
2712 return crate::bindings::CurrencyInfo {
2713 name: var_name,
2714 fraction_size: var_fractionSize,
2715 spacing: var_spacing,
2716 symbol: var_symbol,
2717 uniq_symbol: var_uniqSymbol,
2718 localized_name: var_localizedName,
2719 locale_overrides: var_localeOverrides,
2720 };
2721 }
2722}
2723
2724impl SseDecode for crate::bindings::ExternalInputParser {
2725 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2727 let mut var_providerId = <String>::sse_decode(deserializer);
2728 let mut var_inputRegex = <String>::sse_decode(deserializer);
2729 let mut var_parserUrl = <String>::sse_decode(deserializer);
2730 return crate::bindings::ExternalInputParser {
2731 provider_id: var_providerId,
2732 input_regex: var_inputRegex,
2733 parser_url: var_parserUrl,
2734 };
2735 }
2736}
2737
2738impl SseDecode for f64 {
2739 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2741 deserializer.cursor.read_f64::<NativeEndian>().unwrap()
2742 }
2743}
2744
2745impl SseDecode for crate::model::FetchPaymentProposedFeesRequest {
2746 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2748 let mut var_swapId = <String>::sse_decode(deserializer);
2749 return crate::model::FetchPaymentProposedFeesRequest {
2750 swap_id: var_swapId,
2751 };
2752 }
2753}
2754
2755impl SseDecode for crate::model::FetchPaymentProposedFeesResponse {
2756 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2758 let mut var_swapId = <String>::sse_decode(deserializer);
2759 let mut var_feesSat = <u64>::sse_decode(deserializer);
2760 let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
2761 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
2762 return crate::model::FetchPaymentProposedFeesResponse {
2763 swap_id: var_swapId,
2764 fees_sat: var_feesSat,
2765 payer_amount_sat: var_payerAmountSat,
2766 receiver_amount_sat: var_receiverAmountSat,
2767 };
2768 }
2769}
2770
2771impl SseDecode for crate::bindings::FiatCurrency {
2772 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2774 let mut var_id = <String>::sse_decode(deserializer);
2775 let mut var_info = <crate::bindings::CurrencyInfo>::sse_decode(deserializer);
2776 return crate::bindings::FiatCurrency {
2777 id: var_id,
2778 info: var_info,
2779 };
2780 }
2781}
2782
2783impl SseDecode for crate::model::GetInfoResponse {
2784 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2786 let mut var_walletInfo = <crate::model::WalletInfo>::sse_decode(deserializer);
2787 let mut var_blockchainInfo = <crate::model::BlockchainInfo>::sse_decode(deserializer);
2788 return crate::model::GetInfoResponse {
2789 wallet_info: var_walletInfo,
2790 blockchain_info: var_blockchainInfo,
2791 };
2792 }
2793}
2794
2795impl SseDecode for crate::model::GetPaymentRequest {
2796 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2798 let mut tag_ = <i32>::sse_decode(deserializer);
2799 match tag_ {
2800 0 => {
2801 let mut var_paymentHash = <String>::sse_decode(deserializer);
2802 return crate::model::GetPaymentRequest::PaymentHash {
2803 payment_hash: var_paymentHash,
2804 };
2805 }
2806 1 => {
2807 let mut var_swapId = <String>::sse_decode(deserializer);
2808 return crate::model::GetPaymentRequest::SwapId {
2809 swap_id: var_swapId,
2810 };
2811 }
2812 _ => {
2813 unimplemented!("");
2814 }
2815 }
2816 }
2817}
2818
2819impl SseDecode for i32 {
2820 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2822 deserializer.cursor.read_i32::<NativeEndian>().unwrap()
2823 }
2824}
2825
2826impl SseDecode for i64 {
2827 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2829 deserializer.cursor.read_i64::<NativeEndian>().unwrap()
2830 }
2831}
2832
2833impl SseDecode for crate::bindings::InputType {
2834 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2836 let mut tag_ = <i32>::sse_decode(deserializer);
2837 match tag_ {
2838 0 => {
2839 let mut var_address =
2840 <crate::bindings::BitcoinAddressData>::sse_decode(deserializer);
2841 return crate::bindings::InputType::BitcoinAddress {
2842 address: var_address,
2843 };
2844 }
2845 1 => {
2846 let mut var_address =
2847 <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
2848 return crate::bindings::InputType::LiquidAddress {
2849 address: var_address,
2850 };
2851 }
2852 2 => {
2853 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
2854 return crate::bindings::InputType::Bolt11 {
2855 invoice: var_invoice,
2856 };
2857 }
2858 3 => {
2859 let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
2860 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2861 return crate::bindings::InputType::Bolt12Offer {
2862 offer: var_offer,
2863 bip353_address: var_bip353Address,
2864 };
2865 }
2866 4 => {
2867 let mut var_nodeId = <String>::sse_decode(deserializer);
2868 return crate::bindings::InputType::NodeId {
2869 node_id: var_nodeId,
2870 };
2871 }
2872 5 => {
2873 let mut var_url = <String>::sse_decode(deserializer);
2874 return crate::bindings::InputType::Url { url: var_url };
2875 }
2876 6 => {
2877 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
2878 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2879 return crate::bindings::InputType::LnUrlPay {
2880 data: var_data,
2881 bip353_address: var_bip353Address,
2882 };
2883 }
2884 7 => {
2885 let mut var_data =
2886 <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
2887 return crate::bindings::InputType::LnUrlWithdraw { data: var_data };
2888 }
2889 8 => {
2890 let mut var_data =
2891 <crate::bindings::LnUrlAuthRequestData>::sse_decode(deserializer);
2892 return crate::bindings::InputType::LnUrlAuth { data: var_data };
2893 }
2894 9 => {
2895 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
2896 return crate::bindings::InputType::LnUrlError { data: var_data };
2897 }
2898 _ => {
2899 unimplemented!("");
2900 }
2901 }
2902 }
2903}
2904
2905impl SseDecode for crate::model::LightningPaymentLimitsResponse {
2906 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2908 let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
2909 let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
2910 return crate::model::LightningPaymentLimitsResponse {
2911 send: var_send,
2912 receive: var_receive,
2913 };
2914 }
2915}
2916
2917impl SseDecode for crate::model::Limits {
2918 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2920 let mut var_minSat = <u64>::sse_decode(deserializer);
2921 let mut var_maxSat = <u64>::sse_decode(deserializer);
2922 let mut var_maxZeroConfSat = <u64>::sse_decode(deserializer);
2923 return crate::model::Limits {
2924 min_sat: var_minSat,
2925 max_sat: var_maxSat,
2926 max_zero_conf_sat: var_maxZeroConfSat,
2927 };
2928 }
2929}
2930
2931impl SseDecode for crate::bindings::LiquidAddressData {
2932 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2934 let mut var_address = <String>::sse_decode(deserializer);
2935 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2936 let mut var_assetId = <Option<String>>::sse_decode(deserializer);
2937 let mut var_amount = <Option<f64>>::sse_decode(deserializer);
2938 let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2939 let mut var_label = <Option<String>>::sse_decode(deserializer);
2940 let mut var_message = <Option<String>>::sse_decode(deserializer);
2941 return crate::bindings::LiquidAddressData {
2942 address: var_address,
2943 network: var_network,
2944 asset_id: var_assetId,
2945 amount: var_amount,
2946 amount_sat: var_amountSat,
2947 label: var_label,
2948 message: var_message,
2949 };
2950 }
2951}
2952
2953impl SseDecode for crate::model::LiquidNetwork {
2954 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2956 let mut inner = <i32>::sse_decode(deserializer);
2957 return match inner {
2958 0 => crate::model::LiquidNetwork::Mainnet,
2959 1 => crate::model::LiquidNetwork::Testnet,
2960 2 => crate::model::LiquidNetwork::Regtest,
2961 _ => unreachable!("Invalid variant for LiquidNetwork: {}", inner),
2962 };
2963 }
2964}
2965
2966impl SseDecode for Vec<String> {
2967 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2969 let mut len_ = <i32>::sse_decode(deserializer);
2970 let mut ans_ = vec![];
2971 for idx_ in 0..len_ {
2972 ans_.push(<String>::sse_decode(deserializer));
2973 }
2974 return ans_;
2975 }
2976}
2977
2978impl SseDecode for Vec<crate::model::AssetBalance> {
2979 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2981 let mut len_ = <i32>::sse_decode(deserializer);
2982 let mut ans_ = vec![];
2983 for idx_ in 0..len_ {
2984 ans_.push(<crate::model::AssetBalance>::sse_decode(deserializer));
2985 }
2986 return ans_;
2987 }
2988}
2989
2990impl SseDecode for Vec<crate::model::AssetMetadata> {
2991 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2993 let mut len_ = <i32>::sse_decode(deserializer);
2994 let mut ans_ = vec![];
2995 for idx_ in 0..len_ {
2996 ans_.push(<crate::model::AssetMetadata>::sse_decode(deserializer));
2997 }
2998 return ans_;
2999 }
3000}
3001
3002impl SseDecode for Vec<crate::bindings::ExternalInputParser> {
3003 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3005 let mut len_ = <i32>::sse_decode(deserializer);
3006 let mut ans_ = vec![];
3007 for idx_ in 0..len_ {
3008 ans_.push(<crate::bindings::ExternalInputParser>::sse_decode(
3009 deserializer,
3010 ));
3011 }
3012 return ans_;
3013 }
3014}
3015
3016impl SseDecode for Vec<crate::bindings::FiatCurrency> {
3017 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3019 let mut len_ = <i32>::sse_decode(deserializer);
3020 let mut ans_ = vec![];
3021 for idx_ in 0..len_ {
3022 ans_.push(<crate::bindings::FiatCurrency>::sse_decode(deserializer));
3023 }
3024 return ans_;
3025 }
3026}
3027
3028impl SseDecode for Vec<crate::bindings::LnOfferBlindedPath> {
3029 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3031 let mut len_ = <i32>::sse_decode(deserializer);
3032 let mut ans_ = vec![];
3033 for idx_ in 0..len_ {
3034 ans_.push(<crate::bindings::LnOfferBlindedPath>::sse_decode(
3035 deserializer,
3036 ));
3037 }
3038 return ans_;
3039 }
3040}
3041
3042impl SseDecode for Vec<crate::bindings::LocaleOverrides> {
3043 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3045 let mut len_ = <i32>::sse_decode(deserializer);
3046 let mut ans_ = vec![];
3047 for idx_ in 0..len_ {
3048 ans_.push(<crate::bindings::LocaleOverrides>::sse_decode(deserializer));
3049 }
3050 return ans_;
3051 }
3052}
3053
3054impl SseDecode for Vec<crate::bindings::LocalizedName> {
3055 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3057 let mut len_ = <i32>::sse_decode(deserializer);
3058 let mut ans_ = vec![];
3059 for idx_ in 0..len_ {
3060 ans_.push(<crate::bindings::LocalizedName>::sse_decode(deserializer));
3061 }
3062 return ans_;
3063 }
3064}
3065
3066impl SseDecode for Vec<crate::model::Payment> {
3067 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3069 let mut len_ = <i32>::sse_decode(deserializer);
3070 let mut ans_ = vec![];
3071 for idx_ in 0..len_ {
3072 ans_.push(<crate::model::Payment>::sse_decode(deserializer));
3073 }
3074 return ans_;
3075 }
3076}
3077
3078impl SseDecode for crate::model::ListPaymentDetails {
3079 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3081 let mut tag_ = <i32>::sse_decode(deserializer);
3082 match tag_ {
3083 0 => {
3084 let mut var_assetId = <Option<String>>::sse_decode(deserializer);
3085 let mut var_destination = <Option<String>>::sse_decode(deserializer);
3086 return crate::model::ListPaymentDetails::Liquid {
3087 asset_id: var_assetId,
3088 destination: var_destination,
3089 };
3090 }
3091 1 => {
3092 let mut var_address = <Option<String>>::sse_decode(deserializer);
3093 return crate::model::ListPaymentDetails::Bitcoin {
3094 address: var_address,
3095 };
3096 }
3097 _ => {
3098 unimplemented!("");
3099 }
3100 }
3101 }
3102}
3103
3104impl SseDecode for Vec<crate::model::PaymentState> {
3105 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3107 let mut len_ = <i32>::sse_decode(deserializer);
3108 let mut ans_ = vec![];
3109 for idx_ in 0..len_ {
3110 ans_.push(<crate::model::PaymentState>::sse_decode(deserializer));
3111 }
3112 return ans_;
3113 }
3114}
3115
3116impl SseDecode for Vec<crate::model::PaymentType> {
3117 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3119 let mut len_ = <i32>::sse_decode(deserializer);
3120 let mut ans_ = vec![];
3121 for idx_ in 0..len_ {
3122 ans_.push(<crate::model::PaymentType>::sse_decode(deserializer));
3123 }
3124 return ans_;
3125 }
3126}
3127
3128impl SseDecode for crate::model::ListPaymentsRequest {
3129 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3131 let mut var_filters = <Option<Vec<crate::model::PaymentType>>>::sse_decode(deserializer);
3132 let mut var_states = <Option<Vec<crate::model::PaymentState>>>::sse_decode(deserializer);
3133 let mut var_fromTimestamp = <Option<i64>>::sse_decode(deserializer);
3134 let mut var_toTimestamp = <Option<i64>>::sse_decode(deserializer);
3135 let mut var_offset = <Option<u32>>::sse_decode(deserializer);
3136 let mut var_limit = <Option<u32>>::sse_decode(deserializer);
3137 let mut var_details = <Option<crate::model::ListPaymentDetails>>::sse_decode(deserializer);
3138 let mut var_sortAscending = <Option<bool>>::sse_decode(deserializer);
3139 return crate::model::ListPaymentsRequest {
3140 filters: var_filters,
3141 states: var_states,
3142 from_timestamp: var_fromTimestamp,
3143 to_timestamp: var_toTimestamp,
3144 offset: var_offset,
3145 limit: var_limit,
3146 details: var_details,
3147 sort_ascending: var_sortAscending,
3148 };
3149 }
3150}
3151
3152impl SseDecode for Vec<u8> {
3153 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3155 let mut len_ = <i32>::sse_decode(deserializer);
3156 let mut ans_ = vec![];
3157 for idx_ in 0..len_ {
3158 ans_.push(<u8>::sse_decode(deserializer));
3159 }
3160 return ans_;
3161 }
3162}
3163
3164impl SseDecode for Vec<crate::bindings::Rate> {
3165 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3167 let mut len_ = <i32>::sse_decode(deserializer);
3168 let mut ans_ = vec![];
3169 for idx_ in 0..len_ {
3170 ans_.push(<crate::bindings::Rate>::sse_decode(deserializer));
3171 }
3172 return ans_;
3173 }
3174}
3175
3176impl SseDecode for Vec<crate::model::RefundableSwap> {
3177 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3179 let mut len_ = <i32>::sse_decode(deserializer);
3180 let mut ans_ = vec![];
3181 for idx_ in 0..len_ {
3182 ans_.push(<crate::model::RefundableSwap>::sse_decode(deserializer));
3183 }
3184 return ans_;
3185 }
3186}
3187
3188impl SseDecode for Vec<crate::bindings::RouteHint> {
3189 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3191 let mut len_ = <i32>::sse_decode(deserializer);
3192 let mut ans_ = vec![];
3193 for idx_ in 0..len_ {
3194 ans_.push(<crate::bindings::RouteHint>::sse_decode(deserializer));
3195 }
3196 return ans_;
3197 }
3198}
3199
3200impl SseDecode for Vec<crate::bindings::RouteHintHop> {
3201 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3203 let mut len_ = <i32>::sse_decode(deserializer);
3204 let mut ans_ = vec![];
3205 for idx_ in 0..len_ {
3206 ans_.push(<crate::bindings::RouteHintHop>::sse_decode(deserializer));
3207 }
3208 return ans_;
3209 }
3210}
3211
3212impl SseDecode for crate::bindings::LNInvoice {
3213 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3215 let mut var_bolt11 = <String>::sse_decode(deserializer);
3216 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
3217 let mut var_payeePubkey = <String>::sse_decode(deserializer);
3218 let mut var_paymentHash = <String>::sse_decode(deserializer);
3219 let mut var_description = <Option<String>>::sse_decode(deserializer);
3220 let mut var_descriptionHash = <Option<String>>::sse_decode(deserializer);
3221 let mut var_amountMsat = <Option<u64>>::sse_decode(deserializer);
3222 let mut var_timestamp = <u64>::sse_decode(deserializer);
3223 let mut var_expiry = <u64>::sse_decode(deserializer);
3224 let mut var_routingHints = <Vec<crate::bindings::RouteHint>>::sse_decode(deserializer);
3225 let mut var_paymentSecret = <Vec<u8>>::sse_decode(deserializer);
3226 let mut var_minFinalCltvExpiryDelta = <u64>::sse_decode(deserializer);
3227 return crate::bindings::LNInvoice {
3228 bolt11: var_bolt11,
3229 network: var_network,
3230 payee_pubkey: var_payeePubkey,
3231 payment_hash: var_paymentHash,
3232 description: var_description,
3233 description_hash: var_descriptionHash,
3234 amount_msat: var_amountMsat,
3235 timestamp: var_timestamp,
3236 expiry: var_expiry,
3237 routing_hints: var_routingHints,
3238 payment_secret: var_paymentSecret,
3239 min_final_cltv_expiry_delta: var_minFinalCltvExpiryDelta,
3240 };
3241 }
3242}
3243
3244impl SseDecode for crate::bindings::LNOffer {
3245 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3247 let mut var_offer = <String>::sse_decode(deserializer);
3248 let mut var_chains = <Vec<String>>::sse_decode(deserializer);
3249 let mut var_minAmount = <Option<crate::bindings::Amount>>::sse_decode(deserializer);
3250 let mut var_description = <Option<String>>::sse_decode(deserializer);
3251 let mut var_absoluteExpiry = <Option<u64>>::sse_decode(deserializer);
3252 let mut var_issuer = <Option<String>>::sse_decode(deserializer);
3253 let mut var_signingPubkey = <Option<String>>::sse_decode(deserializer);
3254 let mut var_paths = <Vec<crate::bindings::LnOfferBlindedPath>>::sse_decode(deserializer);
3255 return crate::bindings::LNOffer {
3256 offer: var_offer,
3257 chains: var_chains,
3258 min_amount: var_minAmount,
3259 description: var_description,
3260 absolute_expiry: var_absoluteExpiry,
3261 issuer: var_issuer,
3262 signing_pubkey: var_signingPubkey,
3263 paths: var_paths,
3264 };
3265 }
3266}
3267
3268impl SseDecode for crate::bindings::LnOfferBlindedPath {
3269 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3271 let mut var_blindedHops = <Vec<String>>::sse_decode(deserializer);
3272 return crate::bindings::LnOfferBlindedPath {
3273 blinded_hops: var_blindedHops,
3274 };
3275 }
3276}
3277
3278impl SseDecode for crate::bindings::duplicates::LnUrlAuthError {
3279 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3281 let mut tag_ = <i32>::sse_decode(deserializer);
3282 match tag_ {
3283 0 => {
3284 let mut var_err = <String>::sse_decode(deserializer);
3285 return crate::bindings::duplicates::LnUrlAuthError::Generic { err: var_err };
3286 }
3287 1 => {
3288 let mut var_err = <String>::sse_decode(deserializer);
3289 return crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err: var_err };
3290 }
3291 2 => {
3292 let mut var_err = <String>::sse_decode(deserializer);
3293 return crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
3294 err: var_err,
3295 };
3296 }
3297 _ => {
3298 unimplemented!("");
3299 }
3300 }
3301 }
3302}
3303
3304impl SseDecode for crate::bindings::LnUrlAuthRequestData {
3305 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3307 let mut var_k1 = <String>::sse_decode(deserializer);
3308 let mut var_action = <Option<String>>::sse_decode(deserializer);
3309 let mut var_domain = <String>::sse_decode(deserializer);
3310 let mut var_url = <String>::sse_decode(deserializer);
3311 return crate::bindings::LnUrlAuthRequestData {
3312 k1: var_k1,
3313 action: var_action,
3314 domain: var_domain,
3315 url: var_url,
3316 };
3317 }
3318}
3319
3320impl SseDecode for crate::bindings::duplicates::LnUrlCallbackStatus {
3321 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3323 let mut tag_ = <i32>::sse_decode(deserializer);
3324 match tag_ {
3325 0 => {
3326 return crate::bindings::duplicates::LnUrlCallbackStatus::Ok;
3327 }
3328 1 => {
3329 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3330 return crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
3331 data: var_data,
3332 };
3333 }
3334 _ => {
3335 unimplemented!("");
3336 }
3337 }
3338 }
3339}
3340
3341impl SseDecode for crate::bindings::LnUrlErrorData {
3342 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3344 let mut var_reason = <String>::sse_decode(deserializer);
3345 return crate::bindings::LnUrlErrorData { reason: var_reason };
3346 }
3347}
3348
3349impl SseDecode for crate::model::LnUrlInfo {
3350 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3352 let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3353 let mut var_lnurlPayComment = <Option<String>>::sse_decode(deserializer);
3354 let mut var_lnurlPayDomain = <Option<String>>::sse_decode(deserializer);
3355 let mut var_lnurlPayMetadata = <Option<String>>::sse_decode(deserializer);
3356 let mut var_lnurlPaySuccessAction =
3357 <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3358 let mut var_lnurlPayUnprocessedSuccessAction =
3359 <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
3360 let mut var_lnurlWithdrawEndpoint = <Option<String>>::sse_decode(deserializer);
3361 return crate::model::LnUrlInfo {
3362 ln_address: var_lnAddress,
3363 lnurl_pay_comment: var_lnurlPayComment,
3364 lnurl_pay_domain: var_lnurlPayDomain,
3365 lnurl_pay_metadata: var_lnurlPayMetadata,
3366 lnurl_pay_success_action: var_lnurlPaySuccessAction,
3367 lnurl_pay_unprocessed_success_action: var_lnurlPayUnprocessedSuccessAction,
3368 lnurl_withdraw_endpoint: var_lnurlWithdrawEndpoint,
3369 };
3370 }
3371}
3372
3373impl SseDecode for crate::bindings::duplicates::LnUrlPayError {
3374 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3376 let mut tag_ = <i32>::sse_decode(deserializer);
3377 match tag_ {
3378 0 => {
3379 return crate::bindings::duplicates::LnUrlPayError::AlreadyPaid;
3380 }
3381 1 => {
3382 let mut var_err = <String>::sse_decode(deserializer);
3383 return crate::bindings::duplicates::LnUrlPayError::Generic { err: var_err };
3384 }
3385 2 => {
3386 let mut var_err = <String>::sse_decode(deserializer);
3387 return crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
3388 err: var_err,
3389 };
3390 }
3391 3 => {
3392 let mut var_err = <String>::sse_decode(deserializer);
3393 return crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err: var_err };
3394 }
3395 4 => {
3396 let mut var_err = <String>::sse_decode(deserializer);
3397 return crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err: var_err };
3398 }
3399 5 => {
3400 let mut var_err = <String>::sse_decode(deserializer);
3401 return crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err: var_err };
3402 }
3403 6 => {
3404 let mut var_err = <String>::sse_decode(deserializer);
3405 return crate::bindings::duplicates::LnUrlPayError::InvalidUri { err: var_err };
3406 }
3407 7 => {
3408 let mut var_err = <String>::sse_decode(deserializer);
3409 return crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err: var_err };
3410 }
3411 8 => {
3412 let mut var_err = <String>::sse_decode(deserializer);
3413 return crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err: var_err };
3414 }
3415 9 => {
3416 let mut var_err = <String>::sse_decode(deserializer);
3417 return crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err: var_err };
3418 }
3419 10 => {
3420 let mut var_err = <String>::sse_decode(deserializer);
3421 return crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err: var_err };
3422 }
3423 11 => {
3424 let mut var_err = <String>::sse_decode(deserializer);
3425 return crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
3426 err: var_err,
3427 };
3428 }
3429 12 => {
3430 let mut var_err = <String>::sse_decode(deserializer);
3431 return crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
3432 err: var_err,
3433 };
3434 }
3435 _ => {
3436 unimplemented!("");
3437 }
3438 }
3439 }
3440}
3441
3442impl SseDecode for crate::bindings::LnUrlPayErrorData {
3443 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3445 let mut var_paymentHash = <String>::sse_decode(deserializer);
3446 let mut var_reason = <String>::sse_decode(deserializer);
3447 return crate::bindings::LnUrlPayErrorData {
3448 payment_hash: var_paymentHash,
3449 reason: var_reason,
3450 };
3451 }
3452}
3453
3454impl SseDecode for crate::model::LnUrlPayRequest {
3455 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3457 let mut var_prepareResponse =
3458 <crate::model::PrepareLnUrlPayResponse>::sse_decode(deserializer);
3459 return crate::model::LnUrlPayRequest {
3460 prepare_response: var_prepareResponse,
3461 };
3462 }
3463}
3464
3465impl SseDecode for crate::bindings::LnUrlPayRequestData {
3466 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3468 let mut var_callback = <String>::sse_decode(deserializer);
3469 let mut var_minSendable = <u64>::sse_decode(deserializer);
3470 let mut var_maxSendable = <u64>::sse_decode(deserializer);
3471 let mut var_metadataStr = <String>::sse_decode(deserializer);
3472 let mut var_commentAllowed = <u16>::sse_decode(deserializer);
3473 let mut var_domain = <String>::sse_decode(deserializer);
3474 let mut var_allowsNostr = <bool>::sse_decode(deserializer);
3475 let mut var_nostrPubkey = <Option<String>>::sse_decode(deserializer);
3476 let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3477 return crate::bindings::LnUrlPayRequestData {
3478 callback: var_callback,
3479 min_sendable: var_minSendable,
3480 max_sendable: var_maxSendable,
3481 metadata_str: var_metadataStr,
3482 comment_allowed: var_commentAllowed,
3483 domain: var_domain,
3484 allows_nostr: var_allowsNostr,
3485 nostr_pubkey: var_nostrPubkey,
3486 ln_address: var_lnAddress,
3487 };
3488 }
3489}
3490
3491impl SseDecode for crate::model::LnUrlPayResult {
3492 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3494 let mut tag_ = <i32>::sse_decode(deserializer);
3495 match tag_ {
3496 0 => {
3497 let mut var_data = <crate::model::LnUrlPaySuccessData>::sse_decode(deserializer);
3498 return crate::model::LnUrlPayResult::EndpointSuccess { data: var_data };
3499 }
3500 1 => {
3501 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3502 return crate::model::LnUrlPayResult::EndpointError { data: var_data };
3503 }
3504 2 => {
3505 let mut var_data = <crate::bindings::LnUrlPayErrorData>::sse_decode(deserializer);
3506 return crate::model::LnUrlPayResult::PayError { data: var_data };
3507 }
3508 _ => {
3509 unimplemented!("");
3510 }
3511 }
3512 }
3513}
3514
3515impl SseDecode for crate::model::LnUrlPaySuccessData {
3516 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3518 let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
3519 let mut var_successAction =
3520 <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3521 return crate::model::LnUrlPaySuccessData {
3522 payment: var_payment,
3523 success_action: var_successAction,
3524 };
3525 }
3526}
3527
3528impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawError {
3529 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3531 let mut tag_ = <i32>::sse_decode(deserializer);
3532 match tag_ {
3533 0 => {
3534 let mut var_err = <String>::sse_decode(deserializer);
3535 return crate::bindings::duplicates::LnUrlWithdrawError::Generic { err: var_err };
3536 }
3537 1 => {
3538 let mut var_err = <String>::sse_decode(deserializer);
3539 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
3540 err: var_err,
3541 };
3542 }
3543 2 => {
3544 let mut var_err = <String>::sse_decode(deserializer);
3545 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
3546 err: var_err,
3547 };
3548 }
3549 3 => {
3550 let mut var_err = <String>::sse_decode(deserializer);
3551 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
3552 err: var_err,
3553 };
3554 }
3555 4 => {
3556 let mut var_err = <String>::sse_decode(deserializer);
3557 return crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
3558 err: var_err,
3559 };
3560 }
3561 5 => {
3562 let mut var_err = <String>::sse_decode(deserializer);
3563 return crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
3564 err: var_err,
3565 };
3566 }
3567 _ => {
3568 unimplemented!("");
3569 }
3570 }
3571 }
3572}
3573
3574impl SseDecode for crate::bindings::LnUrlWithdrawRequest {
3575 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3577 let mut var_data = <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
3578 let mut var_amountMsat = <u64>::sse_decode(deserializer);
3579 let mut var_description = <Option<String>>::sse_decode(deserializer);
3580 return crate::bindings::LnUrlWithdrawRequest {
3581 data: var_data,
3582 amount_msat: var_amountMsat,
3583 description: var_description,
3584 };
3585 }
3586}
3587
3588impl SseDecode for crate::bindings::LnUrlWithdrawRequestData {
3589 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3591 let mut var_callback = <String>::sse_decode(deserializer);
3592 let mut var_k1 = <String>::sse_decode(deserializer);
3593 let mut var_defaultDescription = <String>::sse_decode(deserializer);
3594 let mut var_minWithdrawable = <u64>::sse_decode(deserializer);
3595 let mut var_maxWithdrawable = <u64>::sse_decode(deserializer);
3596 return crate::bindings::LnUrlWithdrawRequestData {
3597 callback: var_callback,
3598 k1: var_k1,
3599 default_description: var_defaultDescription,
3600 min_withdrawable: var_minWithdrawable,
3601 max_withdrawable: var_maxWithdrawable,
3602 };
3603 }
3604}
3605
3606impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawResult {
3607 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3609 let mut tag_ = <i32>::sse_decode(deserializer);
3610 match tag_ {
3611 0 => {
3612 let mut var_data =
3613 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3614 deserializer,
3615 );
3616 return crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data: var_data };
3617 }
3618 1 => {
3619 let mut var_data =
3620 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3621 deserializer,
3622 );
3623 return crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
3624 data: var_data,
3625 };
3626 }
3627 2 => {
3628 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3629 return crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
3630 data: var_data,
3631 };
3632 }
3633 _ => {
3634 unimplemented!("");
3635 }
3636 }
3637 }
3638}
3639
3640impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3641 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3643 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
3644 return crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3645 invoice: var_invoice,
3646 };
3647 }
3648}
3649
3650impl SseDecode for crate::bindings::LocaleOverrides {
3651 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3653 let mut var_locale = <String>::sse_decode(deserializer);
3654 let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
3655 let mut var_symbol = <crate::bindings::Symbol>::sse_decode(deserializer);
3656 return crate::bindings::LocaleOverrides {
3657 locale: var_locale,
3658 spacing: var_spacing,
3659 symbol: var_symbol,
3660 };
3661 }
3662}
3663
3664impl SseDecode for crate::bindings::LocalizedName {
3665 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3667 let mut var_locale = <String>::sse_decode(deserializer);
3668 let mut var_name = <String>::sse_decode(deserializer);
3669 return crate::bindings::LocalizedName {
3670 locale: var_locale,
3671 name: var_name,
3672 };
3673 }
3674}
3675
3676impl SseDecode for crate::model::LogEntry {
3677 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3679 let mut var_line = <String>::sse_decode(deserializer);
3680 let mut var_level = <String>::sse_decode(deserializer);
3681 return crate::model::LogEntry {
3682 line: var_line,
3683 level: var_level,
3684 };
3685 }
3686}
3687
3688impl SseDecode for crate::bindings::MessageSuccessActionData {
3689 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3691 let mut var_message = <String>::sse_decode(deserializer);
3692 return crate::bindings::MessageSuccessActionData {
3693 message: var_message,
3694 };
3695 }
3696}
3697
3698impl SseDecode for crate::bindings::Network {
3699 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3701 let mut inner = <i32>::sse_decode(deserializer);
3702 return match inner {
3703 0 => crate::bindings::Network::Bitcoin,
3704 1 => crate::bindings::Network::Testnet,
3705 2 => crate::bindings::Network::Signet,
3706 3 => crate::bindings::Network::Regtest,
3707 _ => unreachable!("Invalid variant for Network: {}", inner),
3708 };
3709 }
3710}
3711
3712impl SseDecode for crate::model::OnchainPaymentLimitsResponse {
3713 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3715 let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
3716 let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
3717 return crate::model::OnchainPaymentLimitsResponse {
3718 send: var_send,
3719 receive: var_receive,
3720 };
3721 }
3722}
3723
3724impl SseDecode for Option<String> {
3725 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3727 if (<bool>::sse_decode(deserializer)) {
3728 return Some(<String>::sse_decode(deserializer));
3729 } else {
3730 return None;
3731 }
3732 }
3733}
3734
3735impl SseDecode for Option<crate::bindings::Amount> {
3736 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3738 if (<bool>::sse_decode(deserializer)) {
3739 return Some(<crate::bindings::Amount>::sse_decode(deserializer));
3740 } else {
3741 return None;
3742 }
3743 }
3744}
3745
3746impl SseDecode for Option<crate::model::AssetInfo> {
3747 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3749 if (<bool>::sse_decode(deserializer)) {
3750 return Some(<crate::model::AssetInfo>::sse_decode(deserializer));
3751 } else {
3752 return None;
3753 }
3754 }
3755}
3756
3757impl SseDecode for Option<bool> {
3758 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3760 if (<bool>::sse_decode(deserializer)) {
3761 return Some(<bool>::sse_decode(deserializer));
3762 } else {
3763 return None;
3764 }
3765 }
3766}
3767
3768impl SseDecode for Option<f64> {
3769 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3771 if (<bool>::sse_decode(deserializer)) {
3772 return Some(<f64>::sse_decode(deserializer));
3773 } else {
3774 return None;
3775 }
3776 }
3777}
3778
3779impl SseDecode for Option<i64> {
3780 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3782 if (<bool>::sse_decode(deserializer)) {
3783 return Some(<i64>::sse_decode(deserializer));
3784 } else {
3785 return None;
3786 }
3787 }
3788}
3789
3790impl SseDecode for Option<crate::model::ListPaymentDetails> {
3791 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3793 if (<bool>::sse_decode(deserializer)) {
3794 return Some(<crate::model::ListPaymentDetails>::sse_decode(deserializer));
3795 } else {
3796 return None;
3797 }
3798 }
3799}
3800
3801impl SseDecode for Option<crate::model::LnUrlInfo> {
3802 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3804 if (<bool>::sse_decode(deserializer)) {
3805 return Some(<crate::model::LnUrlInfo>::sse_decode(deserializer));
3806 } else {
3807 return None;
3808 }
3809 }
3810}
3811
3812impl SseDecode for Option<crate::model::PayAmount> {
3813 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3815 if (<bool>::sse_decode(deserializer)) {
3816 return Some(<crate::model::PayAmount>::sse_decode(deserializer));
3817 } else {
3818 return None;
3819 }
3820 }
3821}
3822
3823impl SseDecode for Option<crate::model::Payment> {
3824 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3826 if (<bool>::sse_decode(deserializer)) {
3827 return Some(<crate::model::Payment>::sse_decode(deserializer));
3828 } else {
3829 return None;
3830 }
3831 }
3832}
3833
3834impl SseDecode for Option<crate::model::ReceiveAmount> {
3835 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3837 if (<bool>::sse_decode(deserializer)) {
3838 return Some(<crate::model::ReceiveAmount>::sse_decode(deserializer));
3839 } else {
3840 return None;
3841 }
3842 }
3843}
3844
3845impl SseDecode for Option<crate::bindings::SuccessAction> {
3846 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3848 if (<bool>::sse_decode(deserializer)) {
3849 return Some(<crate::bindings::SuccessAction>::sse_decode(deserializer));
3850 } else {
3851 return None;
3852 }
3853 }
3854}
3855
3856impl SseDecode for Option<crate::bindings::SuccessActionProcessed> {
3857 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3859 if (<bool>::sse_decode(deserializer)) {
3860 return Some(<crate::bindings::SuccessActionProcessed>::sse_decode(
3861 deserializer,
3862 ));
3863 } else {
3864 return None;
3865 }
3866 }
3867}
3868
3869impl SseDecode for Option<crate::bindings::Symbol> {
3870 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3872 if (<bool>::sse_decode(deserializer)) {
3873 return Some(<crate::bindings::Symbol>::sse_decode(deserializer));
3874 } else {
3875 return None;
3876 }
3877 }
3878}
3879
3880impl SseDecode for Option<u32> {
3881 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3883 if (<bool>::sse_decode(deserializer)) {
3884 return Some(<u32>::sse_decode(deserializer));
3885 } else {
3886 return None;
3887 }
3888 }
3889}
3890
3891impl SseDecode for Option<u64> {
3892 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3894 if (<bool>::sse_decode(deserializer)) {
3895 return Some(<u64>::sse_decode(deserializer));
3896 } else {
3897 return None;
3898 }
3899 }
3900}
3901
3902impl SseDecode for Option<Vec<crate::model::AssetMetadata>> {
3903 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3905 if (<bool>::sse_decode(deserializer)) {
3906 return Some(<Vec<crate::model::AssetMetadata>>::sse_decode(deserializer));
3907 } else {
3908 return None;
3909 }
3910 }
3911}
3912
3913impl SseDecode for Option<Vec<crate::bindings::ExternalInputParser>> {
3914 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3916 if (<bool>::sse_decode(deserializer)) {
3917 return Some(<Vec<crate::bindings::ExternalInputParser>>::sse_decode(
3918 deserializer,
3919 ));
3920 } else {
3921 return None;
3922 }
3923 }
3924}
3925
3926impl SseDecode for Option<Vec<crate::model::PaymentState>> {
3927 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3929 if (<bool>::sse_decode(deserializer)) {
3930 return Some(<Vec<crate::model::PaymentState>>::sse_decode(deserializer));
3931 } else {
3932 return None;
3933 }
3934 }
3935}
3936
3937impl SseDecode for Option<Vec<crate::model::PaymentType>> {
3938 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3940 if (<bool>::sse_decode(deserializer)) {
3941 return Some(<Vec<crate::model::PaymentType>>::sse_decode(deserializer));
3942 } else {
3943 return None;
3944 }
3945 }
3946}
3947
3948impl SseDecode for Option<Vec<u8>> {
3949 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3951 if (<bool>::sse_decode(deserializer)) {
3952 return Some(<Vec<u8>>::sse_decode(deserializer));
3953 } else {
3954 return None;
3955 }
3956 }
3957}
3958
3959impl SseDecode for crate::model::PayAmount {
3960 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3962 let mut tag_ = <i32>::sse_decode(deserializer);
3963 match tag_ {
3964 0 => {
3965 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
3966 return crate::model::PayAmount::Bitcoin {
3967 receiver_amount_sat: var_receiverAmountSat,
3968 };
3969 }
3970 1 => {
3971 let mut var_toAsset = <String>::sse_decode(deserializer);
3972 let mut var_receiverAmount = <f64>::sse_decode(deserializer);
3973 let mut var_estimateAssetFees = <Option<bool>>::sse_decode(deserializer);
3974 let mut var_fromAsset = <Option<String>>::sse_decode(deserializer);
3975 return crate::model::PayAmount::Asset {
3976 to_asset: var_toAsset,
3977 receiver_amount: var_receiverAmount,
3978 estimate_asset_fees: var_estimateAssetFees,
3979 from_asset: var_fromAsset,
3980 };
3981 }
3982 2 => {
3983 return crate::model::PayAmount::Drain;
3984 }
3985 _ => {
3986 unimplemented!("");
3987 }
3988 }
3989 }
3990}
3991
3992impl SseDecode for crate::model::PayOnchainRequest {
3993 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3995 let mut var_address = <String>::sse_decode(deserializer);
3996 let mut var_prepareResponse =
3997 <crate::model::PreparePayOnchainResponse>::sse_decode(deserializer);
3998 return crate::model::PayOnchainRequest {
3999 address: var_address,
4000 prepare_response: var_prepareResponse,
4001 };
4002 }
4003}
4004
4005impl SseDecode for crate::model::Payment {
4006 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4008 let mut var_destination = <Option<String>>::sse_decode(deserializer);
4009 let mut var_txId = <Option<String>>::sse_decode(deserializer);
4010 let mut var_unblindingData = <Option<String>>::sse_decode(deserializer);
4011 let mut var_timestamp = <u32>::sse_decode(deserializer);
4012 let mut var_amountSat = <u64>::sse_decode(deserializer);
4013 let mut var_feesSat = <u64>::sse_decode(deserializer);
4014 let mut var_swapperFeesSat = <Option<u64>>::sse_decode(deserializer);
4015 let mut var_paymentType = <crate::model::PaymentType>::sse_decode(deserializer);
4016 let mut var_status = <crate::model::PaymentState>::sse_decode(deserializer);
4017 let mut var_details = <crate::model::PaymentDetails>::sse_decode(deserializer);
4018 return crate::model::Payment {
4019 destination: var_destination,
4020 tx_id: var_txId,
4021 unblinding_data: var_unblindingData,
4022 timestamp: var_timestamp,
4023 amount_sat: var_amountSat,
4024 fees_sat: var_feesSat,
4025 swapper_fees_sat: var_swapperFeesSat,
4026 payment_type: var_paymentType,
4027 status: var_status,
4028 details: var_details,
4029 };
4030 }
4031}
4032
4033impl SseDecode for crate::model::PaymentDetails {
4034 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4036 let mut tag_ = <i32>::sse_decode(deserializer);
4037 match tag_ {
4038 0 => {
4039 let mut var_swapId = <String>::sse_decode(deserializer);
4040 let mut var_description = <String>::sse_decode(deserializer);
4041 let mut var_liquidExpirationBlockheight = <u32>::sse_decode(deserializer);
4042 let mut var_preimage = <Option<String>>::sse_decode(deserializer);
4043 let mut var_invoice = <Option<String>>::sse_decode(deserializer);
4044 let mut var_bolt12Offer = <Option<String>>::sse_decode(deserializer);
4045 let mut var_paymentHash = <Option<String>>::sse_decode(deserializer);
4046 let mut var_destinationPubkey = <Option<String>>::sse_decode(deserializer);
4047 let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4048 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4049 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4050 let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4051 let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4052 let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4053 return crate::model::PaymentDetails::Lightning {
4054 swap_id: var_swapId,
4055 description: var_description,
4056 liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4057 preimage: var_preimage,
4058 invoice: var_invoice,
4059 bolt12_offer: var_bolt12Offer,
4060 payment_hash: var_paymentHash,
4061 destination_pubkey: var_destinationPubkey,
4062 lnurl_info: var_lnurlInfo,
4063 bip353_address: var_bip353Address,
4064 payer_note: var_payerNote,
4065 claim_tx_id: var_claimTxId,
4066 refund_tx_id: var_refundTxId,
4067 refund_tx_amount_sat: var_refundTxAmountSat,
4068 };
4069 }
4070 1 => {
4071 let mut var_destination = <String>::sse_decode(deserializer);
4072 let mut var_description = <String>::sse_decode(deserializer);
4073 let mut var_assetId = <String>::sse_decode(deserializer);
4074 let mut var_assetInfo = <Option<crate::model::AssetInfo>>::sse_decode(deserializer);
4075 let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4076 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4077 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4078 return crate::model::PaymentDetails::Liquid {
4079 destination: var_destination,
4080 description: var_description,
4081 asset_id: var_assetId,
4082 asset_info: var_assetInfo,
4083 lnurl_info: var_lnurlInfo,
4084 bip353_address: var_bip353Address,
4085 payer_note: var_payerNote,
4086 };
4087 }
4088 2 => {
4089 let mut var_swapId = <String>::sse_decode(deserializer);
4090 let mut var_bitcoinAddress = <String>::sse_decode(deserializer);
4091 let mut var_description = <String>::sse_decode(deserializer);
4092 let mut var_autoAcceptedFees = <bool>::sse_decode(deserializer);
4093 let mut var_liquidExpirationBlockheight = <u32>::sse_decode(deserializer);
4094 let mut var_bitcoinExpirationBlockheight = <u32>::sse_decode(deserializer);
4095 let mut var_lockupTxId = <Option<String>>::sse_decode(deserializer);
4096 let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4097 let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4098 let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4099 return crate::model::PaymentDetails::Bitcoin {
4100 swap_id: var_swapId,
4101 bitcoin_address: var_bitcoinAddress,
4102 description: var_description,
4103 auto_accepted_fees: var_autoAcceptedFees,
4104 liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4105 bitcoin_expiration_blockheight: var_bitcoinExpirationBlockheight,
4106 lockup_tx_id: var_lockupTxId,
4107 claim_tx_id: var_claimTxId,
4108 refund_tx_id: var_refundTxId,
4109 refund_tx_amount_sat: var_refundTxAmountSat,
4110 };
4111 }
4112 _ => {
4113 unimplemented!("");
4114 }
4115 }
4116 }
4117}
4118
4119impl SseDecode for crate::error::PaymentError {
4120 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4122 let mut tag_ = <i32>::sse_decode(deserializer);
4123 match tag_ {
4124 0 => {
4125 return crate::error::PaymentError::AlreadyClaimed;
4126 }
4127 1 => {
4128 return crate::error::PaymentError::AlreadyPaid;
4129 }
4130 2 => {
4131 return crate::error::PaymentError::PaymentInProgress;
4132 }
4133 3 => {
4134 let mut var_min = <u64>::sse_decode(deserializer);
4135 let mut var_max = <u64>::sse_decode(deserializer);
4136 return crate::error::PaymentError::AmountOutOfRange {
4137 min: var_min,
4138 max: var_max,
4139 };
4140 }
4141 4 => {
4142 let mut var_err = <String>::sse_decode(deserializer);
4143 return crate::error::PaymentError::AmountMissing { err: var_err };
4144 }
4145 5 => {
4146 let mut var_err = <String>::sse_decode(deserializer);
4147 return crate::error::PaymentError::AssetError { err: var_err };
4148 }
4149 6 => {
4150 let mut var_err = <String>::sse_decode(deserializer);
4151 return crate::error::PaymentError::InvalidNetwork { err: var_err };
4152 }
4153 7 => {
4154 let mut var_err = <String>::sse_decode(deserializer);
4155 return crate::error::PaymentError::Generic { err: var_err };
4156 }
4157 8 => {
4158 return crate::error::PaymentError::InvalidOrExpiredFees;
4159 }
4160 9 => {
4161 return crate::error::PaymentError::InsufficientFunds;
4162 }
4163 10 => {
4164 let mut var_err = <String>::sse_decode(deserializer);
4165 return crate::error::PaymentError::InvalidDescription { err: var_err };
4166 }
4167 11 => {
4168 let mut var_err = <String>::sse_decode(deserializer);
4169 return crate::error::PaymentError::InvalidInvoice { err: var_err };
4170 }
4171 12 => {
4172 return crate::error::PaymentError::InvalidPreimage;
4173 }
4174 13 => {
4175 return crate::error::PaymentError::PairsNotFound;
4176 }
4177 14 => {
4178 return crate::error::PaymentError::PaymentTimeout;
4179 }
4180 15 => {
4181 return crate::error::PaymentError::PersistError;
4182 }
4183 16 => {
4184 let mut var_err = <String>::sse_decode(deserializer);
4185 return crate::error::PaymentError::ReceiveError { err: var_err };
4186 }
4187 17 => {
4188 let mut var_err = <String>::sse_decode(deserializer);
4189 let mut var_refundTxId = <String>::sse_decode(deserializer);
4190 return crate::error::PaymentError::Refunded {
4191 err: var_err,
4192 refund_tx_id: var_refundTxId,
4193 };
4194 }
4195 18 => {
4196 return crate::error::PaymentError::SelfTransferNotSupported;
4197 }
4198 19 => {
4199 let mut var_err = <String>::sse_decode(deserializer);
4200 return crate::error::PaymentError::SendError { err: var_err };
4201 }
4202 20 => {
4203 let mut var_err = <String>::sse_decode(deserializer);
4204 return crate::error::PaymentError::SignerError { err: var_err };
4205 }
4206 _ => {
4207 unimplemented!("");
4208 }
4209 }
4210 }
4211}
4212
4213impl SseDecode for crate::model::PaymentMethod {
4214 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4216 let mut inner = <i32>::sse_decode(deserializer);
4217 return match inner {
4218 0 => crate::model::PaymentMethod::Lightning,
4219 1 => crate::model::PaymentMethod::Bolt11Invoice,
4220 2 => crate::model::PaymentMethod::Bolt12Offer,
4221 3 => crate::model::PaymentMethod::BitcoinAddress,
4222 4 => crate::model::PaymentMethod::LiquidAddress,
4223 _ => unreachable!("Invalid variant for PaymentMethod: {}", inner),
4224 };
4225 }
4226}
4227
4228impl SseDecode for crate::model::PaymentState {
4229 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4231 let mut inner = <i32>::sse_decode(deserializer);
4232 return match inner {
4233 0 => crate::model::PaymentState::Created,
4234 1 => crate::model::PaymentState::Pending,
4235 2 => crate::model::PaymentState::Complete,
4236 3 => crate::model::PaymentState::Failed,
4237 4 => crate::model::PaymentState::TimedOut,
4238 5 => crate::model::PaymentState::Refundable,
4239 6 => crate::model::PaymentState::RefundPending,
4240 7 => crate::model::PaymentState::WaitingFeeAcceptance,
4241 _ => unreachable!("Invalid variant for PaymentState: {}", inner),
4242 };
4243 }
4244}
4245
4246impl SseDecode for crate::model::PaymentType {
4247 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4249 let mut inner = <i32>::sse_decode(deserializer);
4250 return match inner {
4251 0 => crate::model::PaymentType::Receive,
4252 1 => crate::model::PaymentType::Send,
4253 _ => unreachable!("Invalid variant for PaymentType: {}", inner),
4254 };
4255 }
4256}
4257
4258impl SseDecode for crate::model::PrepareBuyBitcoinRequest {
4259 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4261 let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4262 let mut var_amountSat = <u64>::sse_decode(deserializer);
4263 return crate::model::PrepareBuyBitcoinRequest {
4264 provider: var_provider,
4265 amount_sat: var_amountSat,
4266 };
4267 }
4268}
4269
4270impl SseDecode for crate::model::PrepareBuyBitcoinResponse {
4271 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4273 let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4274 let mut var_amountSat = <u64>::sse_decode(deserializer);
4275 let mut var_feesSat = <u64>::sse_decode(deserializer);
4276 return crate::model::PrepareBuyBitcoinResponse {
4277 provider: var_provider,
4278 amount_sat: var_amountSat,
4279 fees_sat: var_feesSat,
4280 };
4281 }
4282}
4283
4284impl SseDecode for crate::model::PrepareLnUrlPayRequest {
4285 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4287 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4288 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4289 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4290 let mut var_comment = <Option<String>>::sse_decode(deserializer);
4291 let mut var_validateSuccessActionUrl = <Option<bool>>::sse_decode(deserializer);
4292 return crate::model::PrepareLnUrlPayRequest {
4293 data: var_data,
4294 amount: var_amount,
4295 bip353_address: var_bip353Address,
4296 comment: var_comment,
4297 validate_success_action_url: var_validateSuccessActionUrl,
4298 };
4299 }
4300}
4301
4302impl SseDecode for crate::model::PrepareLnUrlPayResponse {
4303 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4305 let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4306 let mut var_feesSat = <u64>::sse_decode(deserializer);
4307 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4308 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4309 let mut var_comment = <Option<String>>::sse_decode(deserializer);
4310 let mut var_successAction =
4311 <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
4312 return crate::model::PrepareLnUrlPayResponse {
4313 destination: var_destination,
4314 fees_sat: var_feesSat,
4315 data: var_data,
4316 amount: var_amount,
4317 comment: var_comment,
4318 success_action: var_successAction,
4319 };
4320 }
4321}
4322
4323impl SseDecode for crate::model::PreparePayOnchainRequest {
4324 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4326 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4327 let mut var_feeRateSatPerVbyte = <Option<u32>>::sse_decode(deserializer);
4328 return crate::model::PreparePayOnchainRequest {
4329 amount: var_amount,
4330 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4331 };
4332 }
4333}
4334
4335impl SseDecode for crate::model::PreparePayOnchainResponse {
4336 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4338 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4339 let mut var_claimFeesSat = <u64>::sse_decode(deserializer);
4340 let mut var_totalFeesSat = <u64>::sse_decode(deserializer);
4341 return crate::model::PreparePayOnchainResponse {
4342 receiver_amount_sat: var_receiverAmountSat,
4343 claim_fees_sat: var_claimFeesSat,
4344 total_fees_sat: var_totalFeesSat,
4345 };
4346 }
4347}
4348
4349impl SseDecode for crate::model::PrepareReceiveRequest {
4350 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4352 let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4353 let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4354 return crate::model::PrepareReceiveRequest {
4355 payment_method: var_paymentMethod,
4356 amount: var_amount,
4357 };
4358 }
4359}
4360
4361impl SseDecode for crate::model::PrepareReceiveResponse {
4362 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4364 let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4365 let mut var_feesSat = <u64>::sse_decode(deserializer);
4366 let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4367 let mut var_minPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4368 let mut var_maxPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4369 let mut var_swapperFeerate = <Option<f64>>::sse_decode(deserializer);
4370 return crate::model::PrepareReceiveResponse {
4371 payment_method: var_paymentMethod,
4372 fees_sat: var_feesSat,
4373 amount: var_amount,
4374 min_payer_amount_sat: var_minPayerAmountSat,
4375 max_payer_amount_sat: var_maxPayerAmountSat,
4376 swapper_feerate: var_swapperFeerate,
4377 };
4378 }
4379}
4380
4381impl SseDecode for crate::model::PrepareRefundRequest {
4382 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4384 let mut var_swapAddress = <String>::sse_decode(deserializer);
4385 let mut var_refundAddress = <String>::sse_decode(deserializer);
4386 let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4387 return crate::model::PrepareRefundRequest {
4388 swap_address: var_swapAddress,
4389 refund_address: var_refundAddress,
4390 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4391 };
4392 }
4393}
4394
4395impl SseDecode for crate::model::PrepareRefundResponse {
4396 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4398 let mut var_txVsize = <u32>::sse_decode(deserializer);
4399 let mut var_txFeeSat = <u64>::sse_decode(deserializer);
4400 let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4401 return crate::model::PrepareRefundResponse {
4402 tx_vsize: var_txVsize,
4403 tx_fee_sat: var_txFeeSat,
4404 last_refund_tx_id: var_lastRefundTxId,
4405 };
4406 }
4407}
4408
4409impl SseDecode for crate::model::PrepareSendRequest {
4410 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4412 let mut var_destination = <String>::sse_decode(deserializer);
4413 let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4414 return crate::model::PrepareSendRequest {
4415 destination: var_destination,
4416 amount: var_amount,
4417 };
4418 }
4419}
4420
4421impl SseDecode for crate::model::PrepareSendResponse {
4422 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4424 let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4425 let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4426 let mut var_feesSat = <Option<u64>>::sse_decode(deserializer);
4427 let mut var_estimatedAssetFees = <Option<f64>>::sse_decode(deserializer);
4428 let mut var_exchangeAmountSat = <Option<u64>>::sse_decode(deserializer);
4429 return crate::model::PrepareSendResponse {
4430 destination: var_destination,
4431 amount: var_amount,
4432 fees_sat: var_feesSat,
4433 estimated_asset_fees: var_estimatedAssetFees,
4434 exchange_amount_sat: var_exchangeAmountSat,
4435 };
4436 }
4437}
4438
4439impl SseDecode for crate::bindings::Rate {
4440 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4442 let mut var_coin = <String>::sse_decode(deserializer);
4443 let mut var_value = <f64>::sse_decode(deserializer);
4444 return crate::bindings::Rate {
4445 coin: var_coin,
4446 value: var_value,
4447 };
4448 }
4449}
4450
4451impl SseDecode for crate::model::ReceiveAmount {
4452 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4454 let mut tag_ = <i32>::sse_decode(deserializer);
4455 match tag_ {
4456 0 => {
4457 let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
4458 return crate::model::ReceiveAmount::Bitcoin {
4459 payer_amount_sat: var_payerAmountSat,
4460 };
4461 }
4462 1 => {
4463 let mut var_assetId = <String>::sse_decode(deserializer);
4464 let mut var_payerAmount = <Option<f64>>::sse_decode(deserializer);
4465 return crate::model::ReceiveAmount::Asset {
4466 asset_id: var_assetId,
4467 payer_amount: var_payerAmount,
4468 };
4469 }
4470 _ => {
4471 unimplemented!("");
4472 }
4473 }
4474 }
4475}
4476
4477impl SseDecode for crate::model::ReceivePaymentRequest {
4478 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4480 let mut var_prepareResponse =
4481 <crate::model::PrepareReceiveResponse>::sse_decode(deserializer);
4482 let mut var_description = <Option<String>>::sse_decode(deserializer);
4483 let mut var_useDescriptionHash = <Option<bool>>::sse_decode(deserializer);
4484 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4485 return crate::model::ReceivePaymentRequest {
4486 prepare_response: var_prepareResponse,
4487 description: var_description,
4488 use_description_hash: var_useDescriptionHash,
4489 payer_note: var_payerNote,
4490 };
4491 }
4492}
4493
4494impl SseDecode for crate::model::ReceivePaymentResponse {
4495 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4497 let mut var_destination = <String>::sse_decode(deserializer);
4498 let mut var_liquidExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4499 let mut var_bitcoinExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4500 return crate::model::ReceivePaymentResponse {
4501 destination: var_destination,
4502 liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4503 bitcoin_expiration_blockheight: var_bitcoinExpirationBlockheight,
4504 };
4505 }
4506}
4507
4508impl SseDecode for crate::model::RecommendedFees {
4509 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4511 let mut var_fastestFee = <u64>::sse_decode(deserializer);
4512 let mut var_halfHourFee = <u64>::sse_decode(deserializer);
4513 let mut var_hourFee = <u64>::sse_decode(deserializer);
4514 let mut var_economyFee = <u64>::sse_decode(deserializer);
4515 let mut var_minimumFee = <u64>::sse_decode(deserializer);
4516 return crate::model::RecommendedFees {
4517 fastest_fee: var_fastestFee,
4518 half_hour_fee: var_halfHourFee,
4519 hour_fee: var_hourFee,
4520 economy_fee: var_economyFee,
4521 minimum_fee: var_minimumFee,
4522 };
4523 }
4524}
4525
4526impl SseDecode for crate::model::RefundRequest {
4527 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4529 let mut var_swapAddress = <String>::sse_decode(deserializer);
4530 let mut var_refundAddress = <String>::sse_decode(deserializer);
4531 let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4532 return crate::model::RefundRequest {
4533 swap_address: var_swapAddress,
4534 refund_address: var_refundAddress,
4535 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4536 };
4537 }
4538}
4539
4540impl SseDecode for crate::model::RefundResponse {
4541 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4543 let mut var_refundTxId = <String>::sse_decode(deserializer);
4544 return crate::model::RefundResponse {
4545 refund_tx_id: var_refundTxId,
4546 };
4547 }
4548}
4549
4550impl SseDecode for crate::model::RefundableSwap {
4551 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4553 let mut var_swapAddress = <String>::sse_decode(deserializer);
4554 let mut var_timestamp = <u32>::sse_decode(deserializer);
4555 let mut var_amountSat = <u64>::sse_decode(deserializer);
4556 let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4557 return crate::model::RefundableSwap {
4558 swap_address: var_swapAddress,
4559 timestamp: var_timestamp,
4560 amount_sat: var_amountSat,
4561 last_refund_tx_id: var_lastRefundTxId,
4562 };
4563 }
4564}
4565
4566impl SseDecode for crate::model::RestoreRequest {
4567 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4569 let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
4570 return crate::model::RestoreRequest {
4571 backup_path: var_backupPath,
4572 };
4573 }
4574}
4575
4576impl SseDecode for crate::bindings::RouteHint {
4577 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4579 let mut var_hops = <Vec<crate::bindings::RouteHintHop>>::sse_decode(deserializer);
4580 return crate::bindings::RouteHint { hops: var_hops };
4581 }
4582}
4583
4584impl SseDecode for crate::bindings::RouteHintHop {
4585 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4587 let mut var_srcNodeId = <String>::sse_decode(deserializer);
4588 let mut var_shortChannelId = <String>::sse_decode(deserializer);
4589 let mut var_feesBaseMsat = <u32>::sse_decode(deserializer);
4590 let mut var_feesProportionalMillionths = <u32>::sse_decode(deserializer);
4591 let mut var_cltvExpiryDelta = <u64>::sse_decode(deserializer);
4592 let mut var_htlcMinimumMsat = <Option<u64>>::sse_decode(deserializer);
4593 let mut var_htlcMaximumMsat = <Option<u64>>::sse_decode(deserializer);
4594 return crate::bindings::RouteHintHop {
4595 src_node_id: var_srcNodeId,
4596 short_channel_id: var_shortChannelId,
4597 fees_base_msat: var_feesBaseMsat,
4598 fees_proportional_millionths: var_feesProportionalMillionths,
4599 cltv_expiry_delta: var_cltvExpiryDelta,
4600 htlc_minimum_msat: var_htlcMinimumMsat,
4601 htlc_maximum_msat: var_htlcMaximumMsat,
4602 };
4603 }
4604}
4605
4606impl SseDecode for crate::error::SdkError {
4607 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4609 let mut tag_ = <i32>::sse_decode(deserializer);
4610 match tag_ {
4611 0 => {
4612 return crate::error::SdkError::AlreadyStarted;
4613 }
4614 1 => {
4615 let mut var_err = <String>::sse_decode(deserializer);
4616 return crate::error::SdkError::Generic { err: var_err };
4617 }
4618 2 => {
4619 return crate::error::SdkError::NotStarted;
4620 }
4621 3 => {
4622 let mut var_err = <String>::sse_decode(deserializer);
4623 return crate::error::SdkError::ServiceConnectivity { err: var_err };
4624 }
4625 _ => {
4626 unimplemented!("");
4627 }
4628 }
4629 }
4630}
4631
4632impl SseDecode for crate::model::SdkEvent {
4633 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4635 let mut tag_ = <i32>::sse_decode(deserializer);
4636 match tag_ {
4637 0 => {
4638 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4639 return crate::model::SdkEvent::PaymentFailed {
4640 details: var_details,
4641 };
4642 }
4643 1 => {
4644 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4645 return crate::model::SdkEvent::PaymentPending {
4646 details: var_details,
4647 };
4648 }
4649 2 => {
4650 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4651 return crate::model::SdkEvent::PaymentRefundable {
4652 details: var_details,
4653 };
4654 }
4655 3 => {
4656 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4657 return crate::model::SdkEvent::PaymentRefunded {
4658 details: var_details,
4659 };
4660 }
4661 4 => {
4662 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4663 return crate::model::SdkEvent::PaymentRefundPending {
4664 details: var_details,
4665 };
4666 }
4667 5 => {
4668 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4669 return crate::model::SdkEvent::PaymentSucceeded {
4670 details: var_details,
4671 };
4672 }
4673 6 => {
4674 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4675 return crate::model::SdkEvent::PaymentWaitingConfirmation {
4676 details: var_details,
4677 };
4678 }
4679 7 => {
4680 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4681 return crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
4682 details: var_details,
4683 };
4684 }
4685 8 => {
4686 return crate::model::SdkEvent::Synced;
4687 }
4688 9 => {
4689 let mut var_didPullNewRecords = <bool>::sse_decode(deserializer);
4690 return crate::model::SdkEvent::DataSynced {
4691 did_pull_new_records: var_didPullNewRecords,
4692 };
4693 }
4694 _ => {
4695 unimplemented!("");
4696 }
4697 }
4698 }
4699}
4700
4701impl SseDecode for crate::model::SendDestination {
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_addressData =
4708 <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
4709 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4710 return crate::model::SendDestination::LiquidAddress {
4711 address_data: var_addressData,
4712 bip353_address: var_bip353Address,
4713 };
4714 }
4715 1 => {
4716 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
4717 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4718 return crate::model::SendDestination::Bolt11 {
4719 invoice: var_invoice,
4720 bip353_address: var_bip353Address,
4721 };
4722 }
4723 2 => {
4724 let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
4725 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4726 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4727 return crate::model::SendDestination::Bolt12 {
4728 offer: var_offer,
4729 receiver_amount_sat: var_receiverAmountSat,
4730 bip353_address: var_bip353Address,
4731 };
4732 }
4733 _ => {
4734 unimplemented!("");
4735 }
4736 }
4737 }
4738}
4739
4740impl SseDecode for crate::model::SendPaymentRequest {
4741 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4743 let mut var_prepareResponse = <crate::model::PrepareSendResponse>::sse_decode(deserializer);
4744 let mut var_useAssetFees = <Option<bool>>::sse_decode(deserializer);
4745 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4746 return crate::model::SendPaymentRequest {
4747 prepare_response: var_prepareResponse,
4748 use_asset_fees: var_useAssetFees,
4749 payer_note: var_payerNote,
4750 };
4751 }
4752}
4753
4754impl SseDecode for crate::model::SendPaymentResponse {
4755 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4757 let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
4758 return crate::model::SendPaymentResponse {
4759 payment: var_payment,
4760 };
4761 }
4762}
4763
4764impl SseDecode for crate::model::SignMessageRequest {
4765 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4767 let mut var_message = <String>::sse_decode(deserializer);
4768 return crate::model::SignMessageRequest {
4769 message: var_message,
4770 };
4771 }
4772}
4773
4774impl SseDecode for crate::model::SignMessageResponse {
4775 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4777 let mut var_signature = <String>::sse_decode(deserializer);
4778 return crate::model::SignMessageResponse {
4779 signature: var_signature,
4780 };
4781 }
4782}
4783
4784impl SseDecode for crate::bindings::SuccessAction {
4785 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4787 let mut tag_ = <i32>::sse_decode(deserializer);
4788 match tag_ {
4789 0 => {
4790 let mut var_data =
4791 <crate::bindings::AesSuccessActionData>::sse_decode(deserializer);
4792 return crate::bindings::SuccessAction::Aes { data: var_data };
4793 }
4794 1 => {
4795 let mut var_data =
4796 <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4797 return crate::bindings::SuccessAction::Message { data: var_data };
4798 }
4799 2 => {
4800 let mut var_data =
4801 <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4802 return crate::bindings::SuccessAction::Url { data: var_data };
4803 }
4804 _ => {
4805 unimplemented!("");
4806 }
4807 }
4808 }
4809}
4810
4811impl SseDecode for crate::bindings::SuccessActionProcessed {
4812 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4814 let mut tag_ = <i32>::sse_decode(deserializer);
4815 match tag_ {
4816 0 => {
4817 let mut var_result =
4818 <crate::bindings::AesSuccessActionDataResult>::sse_decode(deserializer);
4819 return crate::bindings::SuccessActionProcessed::Aes { result: var_result };
4820 }
4821 1 => {
4822 let mut var_data =
4823 <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4824 return crate::bindings::SuccessActionProcessed::Message { data: var_data };
4825 }
4826 2 => {
4827 let mut var_data =
4828 <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4829 return crate::bindings::SuccessActionProcessed::Url { data: var_data };
4830 }
4831 _ => {
4832 unimplemented!("");
4833 }
4834 }
4835 }
4836}
4837
4838impl SseDecode for crate::bindings::Symbol {
4839 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4841 let mut var_grapheme = <Option<String>>::sse_decode(deserializer);
4842 let mut var_template = <Option<String>>::sse_decode(deserializer);
4843 let mut var_rtl = <Option<bool>>::sse_decode(deserializer);
4844 let mut var_position = <Option<u32>>::sse_decode(deserializer);
4845 return crate::bindings::Symbol {
4846 grapheme: var_grapheme,
4847 template: var_template,
4848 rtl: var_rtl,
4849 position: var_position,
4850 };
4851 }
4852}
4853
4854impl SseDecode for u16 {
4855 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4857 deserializer.cursor.read_u16::<NativeEndian>().unwrap()
4858 }
4859}
4860
4861impl SseDecode for u32 {
4862 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4864 deserializer.cursor.read_u32::<NativeEndian>().unwrap()
4865 }
4866}
4867
4868impl SseDecode for u64 {
4869 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4871 deserializer.cursor.read_u64::<NativeEndian>().unwrap()
4872 }
4873}
4874
4875impl SseDecode for u8 {
4876 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4878 deserializer.cursor.read_u8().unwrap()
4879 }
4880}
4881
4882impl SseDecode for () {
4883 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
4885}
4886
4887impl SseDecode for crate::bindings::UrlSuccessActionData {
4888 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4890 let mut var_description = <String>::sse_decode(deserializer);
4891 let mut var_url = <String>::sse_decode(deserializer);
4892 let mut var_matchesCallbackDomain = <bool>::sse_decode(deserializer);
4893 return crate::bindings::UrlSuccessActionData {
4894 description: var_description,
4895 url: var_url,
4896 matches_callback_domain: var_matchesCallbackDomain,
4897 };
4898 }
4899}
4900
4901impl SseDecode for usize {
4902 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4904 deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
4905 }
4906}
4907
4908impl SseDecode for crate::model::WalletInfo {
4909 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4911 let mut var_balanceSat = <u64>::sse_decode(deserializer);
4912 let mut var_pendingSendSat = <u64>::sse_decode(deserializer);
4913 let mut var_pendingReceiveSat = <u64>::sse_decode(deserializer);
4914 let mut var_fingerprint = <String>::sse_decode(deserializer);
4915 let mut var_pubkey = <String>::sse_decode(deserializer);
4916 let mut var_assetBalances = <Vec<crate::model::AssetBalance>>::sse_decode(deserializer);
4917 return crate::model::WalletInfo {
4918 balance_sat: var_balanceSat,
4919 pending_send_sat: var_pendingSendSat,
4920 pending_receive_sat: var_pendingReceiveSat,
4921 fingerprint: var_fingerprint,
4922 pubkey: var_pubkey,
4923 asset_balances: var_assetBalances,
4924 };
4925 }
4926}
4927
4928fn pde_ffi_dispatcher_primary_impl(
4929 func_id: i32,
4930 port: flutter_rust_bridge::for_generated::MessagePort,
4931 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4932 rust_vec_len: i32,
4933 data_len: i32,
4934) {
4935 match func_id {
4937 _ => unreachable!(),
4938 }
4939}
4940
4941fn pde_ffi_dispatcher_sync_impl(
4942 func_id: i32,
4943 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4944 rust_vec_len: i32,
4945 data_len: i32,
4946) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
4947 match func_id {
4949 _ => unreachable!(),
4950 }
4951}
4952
4953impl flutter_rust_bridge::IntoDart for FrbWrapper<BindingLiquidSdk> {
4957 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4958 flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0)
4959 .into_dart()
4960 }
4961}
4962impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<BindingLiquidSdk> {}
4963
4964impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<BindingLiquidSdk>> for BindingLiquidSdk {
4965 fn into_into_dart(self) -> FrbWrapper<BindingLiquidSdk> {
4966 self.into()
4967 }
4968}
4969
4970impl flutter_rust_bridge::IntoDart for crate::model::AcceptPaymentProposedFeesRequest {
4972 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4973 [self.response.into_into_dart().into_dart()].into_dart()
4974 }
4975}
4976impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4977 for crate::model::AcceptPaymentProposedFeesRequest
4978{
4979}
4980impl flutter_rust_bridge::IntoIntoDart<crate::model::AcceptPaymentProposedFeesRequest>
4981 for crate::model::AcceptPaymentProposedFeesRequest
4982{
4983 fn into_into_dart(self) -> crate::model::AcceptPaymentProposedFeesRequest {
4984 self
4985 }
4986}
4987impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionData> {
4989 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4990 [
4991 self.0.description.into_into_dart().into_dart(),
4992 self.0.ciphertext.into_into_dart().into_dart(),
4993 self.0.iv.into_into_dart().into_dart(),
4994 ]
4995 .into_dart()
4996 }
4997}
4998impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4999 for FrbWrapper<crate::bindings::AesSuccessActionData>
5000{
5001}
5002impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionData>>
5003 for crate::bindings::AesSuccessActionData
5004{
5005 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionData> {
5006 self.into()
5007 }
5008}
5009impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5011 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5012 [
5013 self.0.description.into_into_dart().into_dart(),
5014 self.0.plaintext.into_into_dart().into_dart(),
5015 ]
5016 .into_dart()
5017 }
5018}
5019impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5020 for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>
5021{
5022}
5023impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>>
5024 for crate::bindings::AesSuccessActionDataDecrypted
5025{
5026 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5027 self.into()
5028 }
5029}
5030impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5032 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5033 match self.0 {
5034 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
5035 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
5036 }
5037 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
5038 [1.into_dart(), reason.into_into_dart().into_dart()].into_dart()
5039 }
5040 _ => {
5041 unimplemented!("");
5042 }
5043 }
5044 }
5045}
5046impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5047 for FrbWrapper<crate::bindings::AesSuccessActionDataResult>
5048{
5049}
5050impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataResult>>
5051 for crate::bindings::AesSuccessActionDataResult
5052{
5053 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5054 self.into()
5055 }
5056}
5057impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Amount> {
5059 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5060 match self.0 {
5061 crate::bindings::Amount::Bitcoin { amount_msat } => {
5062 [0.into_dart(), amount_msat.into_into_dart().into_dart()].into_dart()
5063 }
5064 crate::bindings::Amount::Currency {
5065 iso4217_code,
5066 fractional_amount,
5067 } => [
5068 1.into_dart(),
5069 iso4217_code.into_into_dart().into_dart(),
5070 fractional_amount.into_into_dart().into_dart(),
5071 ]
5072 .into_dart(),
5073 _ => {
5074 unimplemented!("");
5075 }
5076 }
5077 }
5078}
5079impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5080 for FrbWrapper<crate::bindings::Amount>
5081{
5082}
5083impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Amount>>
5084 for crate::bindings::Amount
5085{
5086 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Amount> {
5087 self.into()
5088 }
5089}
5090impl flutter_rust_bridge::IntoDart for crate::model::AssetBalance {
5092 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5093 [
5094 self.asset_id.into_into_dart().into_dart(),
5095 self.balance_sat.into_into_dart().into_dart(),
5096 self.name.into_into_dart().into_dart(),
5097 self.ticker.into_into_dart().into_dart(),
5098 self.balance.into_into_dart().into_dart(),
5099 ]
5100 .into_dart()
5101 }
5102}
5103impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetBalance {}
5104impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetBalance> for crate::model::AssetBalance {
5105 fn into_into_dart(self) -> crate::model::AssetBalance {
5106 self
5107 }
5108}
5109impl flutter_rust_bridge::IntoDart for crate::model::AssetInfo {
5111 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5112 [
5113 self.name.into_into_dart().into_dart(),
5114 self.ticker.into_into_dart().into_dart(),
5115 self.amount.into_into_dart().into_dart(),
5116 self.fees.into_into_dart().into_dart(),
5117 ]
5118 .into_dart()
5119 }
5120}
5121impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetInfo {}
5122impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetInfo> for crate::model::AssetInfo {
5123 fn into_into_dart(self) -> crate::model::AssetInfo {
5124 self
5125 }
5126}
5127impl flutter_rust_bridge::IntoDart for crate::model::AssetMetadata {
5129 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5130 [
5131 self.asset_id.into_into_dart().into_dart(),
5132 self.name.into_into_dart().into_dart(),
5133 self.ticker.into_into_dart().into_dart(),
5134 self.precision.into_into_dart().into_dart(),
5135 self.fiat_id.into_into_dart().into_dart(),
5136 ]
5137 .into_dart()
5138 }
5139}
5140impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetMetadata {}
5141impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetMetadata>
5142 for crate::model::AssetMetadata
5143{
5144 fn into_into_dart(self) -> crate::model::AssetMetadata {
5145 self
5146 }
5147}
5148impl flutter_rust_bridge::IntoDart for crate::model::BackupRequest {
5150 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5151 [self.backup_path.into_into_dart().into_dart()].into_dart()
5152 }
5153}
5154impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BackupRequest {}
5155impl flutter_rust_bridge::IntoIntoDart<crate::model::BackupRequest>
5156 for crate::model::BackupRequest
5157{
5158 fn into_into_dart(self) -> crate::model::BackupRequest {
5159 self
5160 }
5161}
5162impl flutter_rust_bridge::IntoDart for crate::bindings::BindingEventListener {
5164 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5165 [self.stream.into_into_dart().into_dart()].into_dart()
5166 }
5167}
5168impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5169 for crate::bindings::BindingEventListener
5170{
5171}
5172impl flutter_rust_bridge::IntoIntoDart<crate::bindings::BindingEventListener>
5173 for crate::bindings::BindingEventListener
5174{
5175 fn into_into_dart(self) -> crate::bindings::BindingEventListener {
5176 self
5177 }
5178}
5179impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::BitcoinAddressData> {
5181 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5182 [
5183 self.0.address.into_into_dart().into_dart(),
5184 self.0.network.into_into_dart().into_dart(),
5185 self.0.amount_sat.into_into_dart().into_dart(),
5186 self.0.label.into_into_dart().into_dart(),
5187 self.0.message.into_into_dart().into_dart(),
5188 ]
5189 .into_dart()
5190 }
5191}
5192impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5193 for FrbWrapper<crate::bindings::BitcoinAddressData>
5194{
5195}
5196impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::BitcoinAddressData>>
5197 for crate::bindings::BitcoinAddressData
5198{
5199 fn into_into_dart(self) -> FrbWrapper<crate::bindings::BitcoinAddressData> {
5200 self.into()
5201 }
5202}
5203impl flutter_rust_bridge::IntoDart for crate::model::BlockchainExplorer {
5205 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5206 match self {
5207 crate::model::BlockchainExplorer::Electrum { url } => {
5208 [0.into_dart(), url.into_into_dart().into_dart()].into_dart()
5209 }
5210 crate::model::BlockchainExplorer::Esplora {
5211 url,
5212 use_waterfalls,
5213 } => [
5214 1.into_dart(),
5215 url.into_into_dart().into_dart(),
5216 use_waterfalls.into_into_dart().into_dart(),
5217 ]
5218 .into_dart(),
5219 _ => {
5220 unimplemented!("");
5221 }
5222 }
5223 }
5224}
5225impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5226 for crate::model::BlockchainExplorer
5227{
5228}
5229impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainExplorer>
5230 for crate::model::BlockchainExplorer
5231{
5232 fn into_into_dart(self) -> crate::model::BlockchainExplorer {
5233 self
5234 }
5235}
5236impl flutter_rust_bridge::IntoDart for crate::model::BlockchainInfo {
5238 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5239 [
5240 self.liquid_tip.into_into_dart().into_dart(),
5241 self.bitcoin_tip.into_into_dart().into_dart(),
5242 ]
5243 .into_dart()
5244 }
5245}
5246impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BlockchainInfo {}
5247impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainInfo>
5248 for crate::model::BlockchainInfo
5249{
5250 fn into_into_dart(self) -> crate::model::BlockchainInfo {
5251 self
5252 }
5253}
5254impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinProvider {
5256 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5257 match self {
5258 Self::Moonpay => 0.into_dart(),
5259 _ => unreachable!(),
5260 }
5261 }
5262}
5263impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5264 for crate::model::BuyBitcoinProvider
5265{
5266}
5267impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinProvider>
5268 for crate::model::BuyBitcoinProvider
5269{
5270 fn into_into_dart(self) -> crate::model::BuyBitcoinProvider {
5271 self
5272 }
5273}
5274impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinRequest {
5276 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5277 [
5278 self.prepare_response.into_into_dart().into_dart(),
5279 self.redirect_url.into_into_dart().into_dart(),
5280 ]
5281 .into_dart()
5282 }
5283}
5284impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5285 for crate::model::BuyBitcoinRequest
5286{
5287}
5288impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinRequest>
5289 for crate::model::BuyBitcoinRequest
5290{
5291 fn into_into_dart(self) -> crate::model::BuyBitcoinRequest {
5292 self
5293 }
5294}
5295impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageRequest {
5297 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5298 [
5299 self.message.into_into_dart().into_dart(),
5300 self.pubkey.into_into_dart().into_dart(),
5301 self.signature.into_into_dart().into_dart(),
5302 ]
5303 .into_dart()
5304 }
5305}
5306impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5307 for crate::model::CheckMessageRequest
5308{
5309}
5310impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageRequest>
5311 for crate::model::CheckMessageRequest
5312{
5313 fn into_into_dart(self) -> crate::model::CheckMessageRequest {
5314 self
5315 }
5316}
5317impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageResponse {
5319 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5320 [self.is_valid.into_into_dart().into_dart()].into_dart()
5321 }
5322}
5323impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5324 for crate::model::CheckMessageResponse
5325{
5326}
5327impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageResponse>
5328 for crate::model::CheckMessageResponse
5329{
5330 fn into_into_dart(self) -> crate::model::CheckMessageResponse {
5331 self
5332 }
5333}
5334impl flutter_rust_bridge::IntoDart for crate::model::Config {
5336 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5337 [
5338 self.liquid_explorer.into_into_dart().into_dart(),
5339 self.bitcoin_explorer.into_into_dart().into_dart(),
5340 self.working_dir.into_into_dart().into_dart(),
5341 self.network.into_into_dart().into_dart(),
5342 self.payment_timeout_sec.into_into_dart().into_dart(),
5343 self.sync_service_url.into_into_dart().into_dart(),
5344 self.zero_conf_max_amount_sat.into_into_dart().into_dart(),
5345 self.breez_api_key.into_into_dart().into_dart(),
5346 self.external_input_parsers.into_into_dart().into_dart(),
5347 self.use_default_external_input_parsers
5348 .into_into_dart()
5349 .into_dart(),
5350 self.onchain_fee_rate_leeway_sat
5351 .into_into_dart()
5352 .into_dart(),
5353 self.asset_metadata.into_into_dart().into_dart(),
5354 self.sideswap_api_key.into_into_dart().into_dart(),
5355 self.use_magic_routing_hints.into_into_dart().into_dart(),
5356 ]
5357 .into_dart()
5358 }
5359}
5360impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Config {}
5361impl flutter_rust_bridge::IntoIntoDart<crate::model::Config> for crate::model::Config {
5362 fn into_into_dart(self) -> crate::model::Config {
5363 self
5364 }
5365}
5366impl flutter_rust_bridge::IntoDart for crate::model::ConnectRequest {
5368 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5369 [
5370 self.config.into_into_dart().into_dart(),
5371 self.mnemonic.into_into_dart().into_dart(),
5372 self.passphrase.into_into_dart().into_dart(),
5373 self.seed.into_into_dart().into_dart(),
5374 ]
5375 .into_dart()
5376 }
5377}
5378impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ConnectRequest {}
5379impl flutter_rust_bridge::IntoIntoDart<crate::model::ConnectRequest>
5380 for crate::model::ConnectRequest
5381{
5382 fn into_into_dart(self) -> crate::model::ConnectRequest {
5383 self
5384 }
5385}
5386impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceRequest {
5388 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5389 [
5390 self.offer.into_into_dart().into_dart(),
5391 self.invoice_request.into_into_dart().into_dart(),
5392 ]
5393 .into_dart()
5394 }
5395}
5396impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5397 for crate::model::CreateBolt12InvoiceRequest
5398{
5399}
5400impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceRequest>
5401 for crate::model::CreateBolt12InvoiceRequest
5402{
5403 fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceRequest {
5404 self
5405 }
5406}
5407impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceResponse {
5409 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5410 [self.invoice.into_into_dart().into_dart()].into_dart()
5411 }
5412}
5413impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5414 for crate::model::CreateBolt12InvoiceResponse
5415{
5416}
5417impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceResponse>
5418 for crate::model::CreateBolt12InvoiceResponse
5419{
5420 fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceResponse {
5421 self
5422 }
5423}
5424impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::CurrencyInfo> {
5426 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5427 [
5428 self.0.name.into_into_dart().into_dart(),
5429 self.0.fraction_size.into_into_dart().into_dart(),
5430 self.0.spacing.into_into_dart().into_dart(),
5431 self.0.symbol.into_into_dart().into_dart(),
5432 self.0.uniq_symbol.into_into_dart().into_dart(),
5433 self.0.localized_name.into_into_dart().into_dart(),
5434 self.0.locale_overrides.into_into_dart().into_dart(),
5435 ]
5436 .into_dart()
5437 }
5438}
5439impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5440 for FrbWrapper<crate::bindings::CurrencyInfo>
5441{
5442}
5443impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::CurrencyInfo>>
5444 for crate::bindings::CurrencyInfo
5445{
5446 fn into_into_dart(self) -> FrbWrapper<crate::bindings::CurrencyInfo> {
5447 self.into()
5448 }
5449}
5450impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::ExternalInputParser> {
5452 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5453 [
5454 self.0.provider_id.into_into_dart().into_dart(),
5455 self.0.input_regex.into_into_dart().into_dart(),
5456 self.0.parser_url.into_into_dart().into_dart(),
5457 ]
5458 .into_dart()
5459 }
5460}
5461impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5462 for FrbWrapper<crate::bindings::ExternalInputParser>
5463{
5464}
5465impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::ExternalInputParser>>
5466 for crate::bindings::ExternalInputParser
5467{
5468 fn into_into_dart(self) -> FrbWrapper<crate::bindings::ExternalInputParser> {
5469 self.into()
5470 }
5471}
5472impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesRequest {
5474 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5475 [self.swap_id.into_into_dart().into_dart()].into_dart()
5476 }
5477}
5478impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5479 for crate::model::FetchPaymentProposedFeesRequest
5480{
5481}
5482impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesRequest>
5483 for crate::model::FetchPaymentProposedFeesRequest
5484{
5485 fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesRequest {
5486 self
5487 }
5488}
5489impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesResponse {
5491 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5492 [
5493 self.swap_id.into_into_dart().into_dart(),
5494 self.fees_sat.into_into_dart().into_dart(),
5495 self.payer_amount_sat.into_into_dart().into_dart(),
5496 self.receiver_amount_sat.into_into_dart().into_dart(),
5497 ]
5498 .into_dart()
5499 }
5500}
5501impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5502 for crate::model::FetchPaymentProposedFeesResponse
5503{
5504}
5505impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesResponse>
5506 for crate::model::FetchPaymentProposedFeesResponse
5507{
5508 fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesResponse {
5509 self
5510 }
5511}
5512impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::FiatCurrency> {
5514 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5515 [
5516 self.0.id.into_into_dart().into_dart(),
5517 self.0.info.into_into_dart().into_dart(),
5518 ]
5519 .into_dart()
5520 }
5521}
5522impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5523 for FrbWrapper<crate::bindings::FiatCurrency>
5524{
5525}
5526impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::FiatCurrency>>
5527 for crate::bindings::FiatCurrency
5528{
5529 fn into_into_dart(self) -> FrbWrapper<crate::bindings::FiatCurrency> {
5530 self.into()
5531 }
5532}
5533impl flutter_rust_bridge::IntoDart for crate::model::GetInfoResponse {
5535 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5536 [
5537 self.wallet_info.into_into_dart().into_dart(),
5538 self.blockchain_info.into_into_dart().into_dart(),
5539 ]
5540 .into_dart()
5541 }
5542}
5543impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::GetInfoResponse {}
5544impl flutter_rust_bridge::IntoIntoDart<crate::model::GetInfoResponse>
5545 for crate::model::GetInfoResponse
5546{
5547 fn into_into_dart(self) -> crate::model::GetInfoResponse {
5548 self
5549 }
5550}
5551impl flutter_rust_bridge::IntoDart for crate::model::GetPaymentRequest {
5553 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5554 match self {
5555 crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
5556 [0.into_dart(), payment_hash.into_into_dart().into_dart()].into_dart()
5557 }
5558 crate::model::GetPaymentRequest::SwapId { swap_id } => {
5559 [1.into_dart(), swap_id.into_into_dart().into_dart()].into_dart()
5560 }
5561 _ => {
5562 unimplemented!("");
5563 }
5564 }
5565 }
5566}
5567impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5568 for crate::model::GetPaymentRequest
5569{
5570}
5571impl flutter_rust_bridge::IntoIntoDart<crate::model::GetPaymentRequest>
5572 for crate::model::GetPaymentRequest
5573{
5574 fn into_into_dart(self) -> crate::model::GetPaymentRequest {
5575 self
5576 }
5577}
5578impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::InputType> {
5580 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5581 match self.0 {
5582 crate::bindings::InputType::BitcoinAddress { address } => {
5583 [0.into_dart(), address.into_into_dart().into_dart()].into_dart()
5584 }
5585 crate::bindings::InputType::LiquidAddress { address } => {
5586 [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5587 }
5588 crate::bindings::InputType::Bolt11 { invoice } => {
5589 [2.into_dart(), invoice.into_into_dart().into_dart()].into_dart()
5590 }
5591 crate::bindings::InputType::Bolt12Offer {
5592 offer,
5593 bip353_address,
5594 } => [
5595 3.into_dart(),
5596 offer.into_into_dart().into_dart(),
5597 bip353_address.into_into_dart().into_dart(),
5598 ]
5599 .into_dart(),
5600 crate::bindings::InputType::NodeId { node_id } => {
5601 [4.into_dart(), node_id.into_into_dart().into_dart()].into_dart()
5602 }
5603 crate::bindings::InputType::Url { url } => {
5604 [5.into_dart(), url.into_into_dart().into_dart()].into_dart()
5605 }
5606 crate::bindings::InputType::LnUrlPay {
5607 data,
5608 bip353_address,
5609 } => [
5610 6.into_dart(),
5611 data.into_into_dart().into_dart(),
5612 bip353_address.into_into_dart().into_dart(),
5613 ]
5614 .into_dart(),
5615 crate::bindings::InputType::LnUrlWithdraw { data } => {
5616 [7.into_dart(), data.into_into_dart().into_dart()].into_dart()
5617 }
5618 crate::bindings::InputType::LnUrlAuth { data } => {
5619 [8.into_dart(), data.into_into_dart().into_dart()].into_dart()
5620 }
5621 crate::bindings::InputType::LnUrlError { data } => {
5622 [9.into_dart(), data.into_into_dart().into_dart()].into_dart()
5623 }
5624 _ => {
5625 unimplemented!("");
5626 }
5627 }
5628 }
5629}
5630impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5631 for FrbWrapper<crate::bindings::InputType>
5632{
5633}
5634impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::InputType>>
5635 for crate::bindings::InputType
5636{
5637 fn into_into_dart(self) -> FrbWrapper<crate::bindings::InputType> {
5638 self.into()
5639 }
5640}
5641impl flutter_rust_bridge::IntoDart for crate::model::LightningPaymentLimitsResponse {
5643 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5644 [
5645 self.send.into_into_dart().into_dart(),
5646 self.receive.into_into_dart().into_dart(),
5647 ]
5648 .into_dart()
5649 }
5650}
5651impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5652 for crate::model::LightningPaymentLimitsResponse
5653{
5654}
5655impl flutter_rust_bridge::IntoIntoDart<crate::model::LightningPaymentLimitsResponse>
5656 for crate::model::LightningPaymentLimitsResponse
5657{
5658 fn into_into_dart(self) -> crate::model::LightningPaymentLimitsResponse {
5659 self
5660 }
5661}
5662impl flutter_rust_bridge::IntoDart for crate::model::Limits {
5664 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5665 [
5666 self.min_sat.into_into_dart().into_dart(),
5667 self.max_sat.into_into_dart().into_dart(),
5668 self.max_zero_conf_sat.into_into_dart().into_dart(),
5669 ]
5670 .into_dart()
5671 }
5672}
5673impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Limits {}
5674impl flutter_rust_bridge::IntoIntoDart<crate::model::Limits> for crate::model::Limits {
5675 fn into_into_dart(self) -> crate::model::Limits {
5676 self
5677 }
5678}
5679impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LiquidAddressData> {
5681 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5682 [
5683 self.0.address.into_into_dart().into_dart(),
5684 self.0.network.into_into_dart().into_dart(),
5685 self.0.asset_id.into_into_dart().into_dart(),
5686 self.0.amount.into_into_dart().into_dart(),
5687 self.0.amount_sat.into_into_dart().into_dart(),
5688 self.0.label.into_into_dart().into_dart(),
5689 self.0.message.into_into_dart().into_dart(),
5690 ]
5691 .into_dart()
5692 }
5693}
5694impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5695 for FrbWrapper<crate::bindings::LiquidAddressData>
5696{
5697}
5698impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LiquidAddressData>>
5699 for crate::bindings::LiquidAddressData
5700{
5701 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LiquidAddressData> {
5702 self.into()
5703 }
5704}
5705impl flutter_rust_bridge::IntoDart for crate::model::LiquidNetwork {
5707 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5708 match self {
5709 Self::Mainnet => 0.into_dart(),
5710 Self::Testnet => 1.into_dart(),
5711 Self::Regtest => 2.into_dart(),
5712 _ => unreachable!(),
5713 }
5714 }
5715}
5716impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LiquidNetwork {}
5717impl flutter_rust_bridge::IntoIntoDart<crate::model::LiquidNetwork>
5718 for crate::model::LiquidNetwork
5719{
5720 fn into_into_dart(self) -> crate::model::LiquidNetwork {
5721 self
5722 }
5723}
5724impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentDetails {
5726 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5727 match self {
5728 crate::model::ListPaymentDetails::Liquid {
5729 asset_id,
5730 destination,
5731 } => [
5732 0.into_dart(),
5733 asset_id.into_into_dart().into_dart(),
5734 destination.into_into_dart().into_dart(),
5735 ]
5736 .into_dart(),
5737 crate::model::ListPaymentDetails::Bitcoin { address } => {
5738 [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5739 }
5740 _ => {
5741 unimplemented!("");
5742 }
5743 }
5744 }
5745}
5746impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5747 for crate::model::ListPaymentDetails
5748{
5749}
5750impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentDetails>
5751 for crate::model::ListPaymentDetails
5752{
5753 fn into_into_dart(self) -> crate::model::ListPaymentDetails {
5754 self
5755 }
5756}
5757impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentsRequest {
5759 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5760 [
5761 self.filters.into_into_dart().into_dart(),
5762 self.states.into_into_dart().into_dart(),
5763 self.from_timestamp.into_into_dart().into_dart(),
5764 self.to_timestamp.into_into_dart().into_dart(),
5765 self.offset.into_into_dart().into_dart(),
5766 self.limit.into_into_dart().into_dart(),
5767 self.details.into_into_dart().into_dart(),
5768 self.sort_ascending.into_into_dart().into_dart(),
5769 ]
5770 .into_dart()
5771 }
5772}
5773impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5774 for crate::model::ListPaymentsRequest
5775{
5776}
5777impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentsRequest>
5778 for crate::model::ListPaymentsRequest
5779{
5780 fn into_into_dart(self) -> crate::model::ListPaymentsRequest {
5781 self
5782 }
5783}
5784impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNInvoice> {
5786 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5787 [
5788 self.0.bolt11.into_into_dart().into_dart(),
5789 self.0.network.into_into_dart().into_dart(),
5790 self.0.payee_pubkey.into_into_dart().into_dart(),
5791 self.0.payment_hash.into_into_dart().into_dart(),
5792 self.0.description.into_into_dart().into_dart(),
5793 self.0.description_hash.into_into_dart().into_dart(),
5794 self.0.amount_msat.into_into_dart().into_dart(),
5795 self.0.timestamp.into_into_dart().into_dart(),
5796 self.0.expiry.into_into_dart().into_dart(),
5797 self.0.routing_hints.into_into_dart().into_dart(),
5798 self.0.payment_secret.into_into_dart().into_dart(),
5799 self.0
5800 .min_final_cltv_expiry_delta
5801 .into_into_dart()
5802 .into_dart(),
5803 ]
5804 .into_dart()
5805 }
5806}
5807impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5808 for FrbWrapper<crate::bindings::LNInvoice>
5809{
5810}
5811impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNInvoice>>
5812 for crate::bindings::LNInvoice
5813{
5814 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNInvoice> {
5815 self.into()
5816 }
5817}
5818impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNOffer> {
5820 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5821 [
5822 self.0.offer.into_into_dart().into_dart(),
5823 self.0.chains.into_into_dart().into_dart(),
5824 self.0.min_amount.into_into_dart().into_dart(),
5825 self.0.description.into_into_dart().into_dart(),
5826 self.0.absolute_expiry.into_into_dart().into_dart(),
5827 self.0.issuer.into_into_dart().into_dart(),
5828 self.0.signing_pubkey.into_into_dart().into_dart(),
5829 self.0.paths.into_into_dart().into_dart(),
5830 ]
5831 .into_dart()
5832 }
5833}
5834impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5835 for FrbWrapper<crate::bindings::LNOffer>
5836{
5837}
5838impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNOffer>>
5839 for crate::bindings::LNOffer
5840{
5841 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNOffer> {
5842 self.into()
5843 }
5844}
5845impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5847 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5848 [self.0.blinded_hops.into_into_dart().into_dart()].into_dart()
5849 }
5850}
5851impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5852 for FrbWrapper<crate::bindings::LnOfferBlindedPath>
5853{
5854}
5855impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnOfferBlindedPath>>
5856 for crate::bindings::LnOfferBlindedPath
5857{
5858 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5859 self.into()
5860 }
5861}
5862impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlAuthError {
5864 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5865 match self {
5866 crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
5867 [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
5868 }
5869 crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
5870 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5871 }
5872 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
5873 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5874 }
5875 _ => {
5876 unimplemented!("");
5877 }
5878 }
5879 }
5880}
5881impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5882 for crate::bindings::duplicates::LnUrlAuthError
5883{
5884}
5885impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlAuthError>
5886 for crate::bindings::duplicates::LnUrlAuthError
5887{
5888 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlAuthError {
5889 self
5890 }
5891}
5892impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5894 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5895 [
5896 self.0.k1.into_into_dart().into_dart(),
5897 self.0.action.into_into_dart().into_dart(),
5898 self.0.domain.into_into_dart().into_dart(),
5899 self.0.url.into_into_dart().into_dart(),
5900 ]
5901 .into_dart()
5902 }
5903}
5904impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5905 for FrbWrapper<crate::bindings::LnUrlAuthRequestData>
5906{
5907}
5908impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlAuthRequestData>>
5909 for crate::bindings::LnUrlAuthRequestData
5910{
5911 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5912 self.into()
5913 }
5914}
5915impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlCallbackStatus {
5917 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5918 match self {
5919 crate::bindings::duplicates::LnUrlCallbackStatus::Ok => [0.into_dart()].into_dart(),
5920 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
5921 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
5922 }
5923 _ => {
5924 unimplemented!("");
5925 }
5926 }
5927 }
5928}
5929impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5930 for crate::bindings::duplicates::LnUrlCallbackStatus
5931{
5932}
5933impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlCallbackStatus>
5934 for crate::bindings::duplicates::LnUrlCallbackStatus
5935{
5936 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
5937 self
5938 }
5939}
5940impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlErrorData> {
5942 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5943 [self.0.reason.into_into_dart().into_dart()].into_dart()
5944 }
5945}
5946impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5947 for FrbWrapper<crate::bindings::LnUrlErrorData>
5948{
5949}
5950impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlErrorData>>
5951 for crate::bindings::LnUrlErrorData
5952{
5953 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlErrorData> {
5954 self.into()
5955 }
5956}
5957impl flutter_rust_bridge::IntoDart for crate::model::LnUrlInfo {
5959 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5960 [
5961 self.ln_address.into_into_dart().into_dart(),
5962 self.lnurl_pay_comment.into_into_dart().into_dart(),
5963 self.lnurl_pay_domain.into_into_dart().into_dart(),
5964 self.lnurl_pay_metadata.into_into_dart().into_dart(),
5965 self.lnurl_pay_success_action.into_into_dart().into_dart(),
5966 self.lnurl_pay_unprocessed_success_action
5967 .into_into_dart()
5968 .into_dart(),
5969 self.lnurl_withdraw_endpoint.into_into_dart().into_dart(),
5970 ]
5971 .into_dart()
5972 }
5973}
5974impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlInfo {}
5975impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlInfo> for crate::model::LnUrlInfo {
5976 fn into_into_dart(self) -> crate::model::LnUrlInfo {
5977 self
5978 }
5979}
5980impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlPayError {
5982 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5983 match self {
5984 crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => [0.into_dart()].into_dart(),
5985 crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
5986 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5987 }
5988 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
5989 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5990 }
5991 crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
5992 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
5993 }
5994 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
5995 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
5996 }
5997 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
5998 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
5999 }
6000 crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
6001 [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
6002 }
6003 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
6004 [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
6005 }
6006 crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
6007 [8.into_dart(), err.into_into_dart().into_dart()].into_dart()
6008 }
6009 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
6010 [9.into_dart(), err.into_into_dart().into_dart()].into_dart()
6011 }
6012 crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
6013 [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6014 }
6015 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
6016 [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6017 }
6018 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
6019 [12.into_dart(), err.into_into_dart().into_dart()].into_dart()
6020 }
6021 _ => {
6022 unimplemented!("");
6023 }
6024 }
6025 }
6026}
6027impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6028 for crate::bindings::duplicates::LnUrlPayError
6029{
6030}
6031impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlPayError>
6032 for crate::bindings::duplicates::LnUrlPayError
6033{
6034 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlPayError {
6035 self
6036 }
6037}
6038impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6040 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6041 [
6042 self.0.payment_hash.into_into_dart().into_dart(),
6043 self.0.reason.into_into_dart().into_dart(),
6044 ]
6045 .into_dart()
6046 }
6047}
6048impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6049 for FrbWrapper<crate::bindings::LnUrlPayErrorData>
6050{
6051}
6052impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayErrorData>>
6053 for crate::bindings::LnUrlPayErrorData
6054{
6055 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6056 self.into()
6057 }
6058}
6059impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayRequest {
6061 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6062 [self.prepare_response.into_into_dart().into_dart()].into_dart()
6063 }
6064}
6065impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayRequest {}
6066impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayRequest>
6067 for crate::model::LnUrlPayRequest
6068{
6069 fn into_into_dart(self) -> crate::model::LnUrlPayRequest {
6070 self
6071 }
6072}
6073impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6075 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6076 [
6077 self.0.callback.into_into_dart().into_dart(),
6078 self.0.min_sendable.into_into_dart().into_dart(),
6079 self.0.max_sendable.into_into_dart().into_dart(),
6080 self.0.metadata_str.into_into_dart().into_dart(),
6081 self.0.comment_allowed.into_into_dart().into_dart(),
6082 self.0.domain.into_into_dart().into_dart(),
6083 self.0.allows_nostr.into_into_dart().into_dart(),
6084 self.0.nostr_pubkey.into_into_dart().into_dart(),
6085 self.0.ln_address.into_into_dart().into_dart(),
6086 ]
6087 .into_dart()
6088 }
6089}
6090impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6091 for FrbWrapper<crate::bindings::LnUrlPayRequestData>
6092{
6093}
6094impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayRequestData>>
6095 for crate::bindings::LnUrlPayRequestData
6096{
6097 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6098 self.into()
6099 }
6100}
6101impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayResult {
6103 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6104 match self {
6105 crate::model::LnUrlPayResult::EndpointSuccess { data } => {
6106 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6107 }
6108 crate::model::LnUrlPayResult::EndpointError { data } => {
6109 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6110 }
6111 crate::model::LnUrlPayResult::PayError { data } => {
6112 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6113 }
6114 _ => {
6115 unimplemented!("");
6116 }
6117 }
6118 }
6119}
6120impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayResult {}
6121impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayResult>
6122 for crate::model::LnUrlPayResult
6123{
6124 fn into_into_dart(self) -> crate::model::LnUrlPayResult {
6125 self
6126 }
6127}
6128impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPaySuccessData {
6130 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6131 [
6132 self.payment.into_into_dart().into_dart(),
6133 self.success_action.into_into_dart().into_dart(),
6134 ]
6135 .into_dart()
6136 }
6137}
6138impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6139 for crate::model::LnUrlPaySuccessData
6140{
6141}
6142impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPaySuccessData>
6143 for crate::model::LnUrlPaySuccessData
6144{
6145 fn into_into_dart(self) -> crate::model::LnUrlPaySuccessData {
6146 self
6147 }
6148}
6149impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawError {
6151 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6152 match self {
6153 crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
6154 [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
6155 }
6156 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
6157 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
6158 }
6159 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
6160 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
6161 }
6162 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
6163 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
6164 }
6165 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
6166 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6167 }
6168 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
6169 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6170 }
6171 _ => {
6172 unimplemented!("");
6173 }
6174 }
6175 }
6176}
6177impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6178 for crate::bindings::duplicates::LnUrlWithdrawError
6179{
6180}
6181impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawError>
6182 for crate::bindings::duplicates::LnUrlWithdrawError
6183{
6184 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
6185 self
6186 }
6187}
6188impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6190 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6191 [
6192 self.0.data.into_into_dart().into_dart(),
6193 self.0.amount_msat.into_into_dart().into_dart(),
6194 self.0.description.into_into_dart().into_dart(),
6195 ]
6196 .into_dart()
6197 }
6198}
6199impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6200 for FrbWrapper<crate::bindings::LnUrlWithdrawRequest>
6201{
6202}
6203impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequest>>
6204 for crate::bindings::LnUrlWithdrawRequest
6205{
6206 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6207 self.into()
6208 }
6209}
6210impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6212 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6213 [
6214 self.0.callback.into_into_dart().into_dart(),
6215 self.0.k1.into_into_dart().into_dart(),
6216 self.0.default_description.into_into_dart().into_dart(),
6217 self.0.min_withdrawable.into_into_dart().into_dart(),
6218 self.0.max_withdrawable.into_into_dart().into_dart(),
6219 ]
6220 .into_dart()
6221 }
6222}
6223impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6224 for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>
6225{
6226}
6227impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>>
6228 for crate::bindings::LnUrlWithdrawRequestData
6229{
6230 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6231 self.into()
6232 }
6233}
6234impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawResult {
6236 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6237 match self {
6238 crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
6239 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6240 }
6241 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
6242 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6243 }
6244 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
6245 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6246 }
6247 _ => {
6248 unimplemented!("");
6249 }
6250 }
6251 }
6252}
6253impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6254 for crate::bindings::duplicates::LnUrlWithdrawResult
6255{
6256}
6257impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawResult>
6258 for crate::bindings::duplicates::LnUrlWithdrawResult
6259{
6260 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
6261 self
6262 }
6263}
6264impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6266 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6267 [self.invoice.into_into_dart().into_dart()].into_dart()
6268 }
6269}
6270impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6271 for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6272{
6273}
6274impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
6275 for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6276{
6277 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6278 self
6279 }
6280}
6281impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocaleOverrides> {
6283 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6284 [
6285 self.0.locale.into_into_dart().into_dart(),
6286 self.0.spacing.into_into_dart().into_dart(),
6287 self.0.symbol.into_into_dart().into_dart(),
6288 ]
6289 .into_dart()
6290 }
6291}
6292impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6293 for FrbWrapper<crate::bindings::LocaleOverrides>
6294{
6295}
6296impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocaleOverrides>>
6297 for crate::bindings::LocaleOverrides
6298{
6299 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocaleOverrides> {
6300 self.into()
6301 }
6302}
6303impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocalizedName> {
6305 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6306 [
6307 self.0.locale.into_into_dart().into_dart(),
6308 self.0.name.into_into_dart().into_dart(),
6309 ]
6310 .into_dart()
6311 }
6312}
6313impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6314 for FrbWrapper<crate::bindings::LocalizedName>
6315{
6316}
6317impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocalizedName>>
6318 for crate::bindings::LocalizedName
6319{
6320 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocalizedName> {
6321 self.into()
6322 }
6323}
6324impl flutter_rust_bridge::IntoDart for crate::model::LogEntry {
6326 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6327 [
6328 self.line.into_into_dart().into_dart(),
6329 self.level.into_into_dart().into_dart(),
6330 ]
6331 .into_dart()
6332 }
6333}
6334impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LogEntry {}
6335impl flutter_rust_bridge::IntoIntoDart<crate::model::LogEntry> for crate::model::LogEntry {
6336 fn into_into_dart(self) -> crate::model::LogEntry {
6337 self
6338 }
6339}
6340impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::MessageSuccessActionData> {
6342 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6343 [self.0.message.into_into_dart().into_dart()].into_dart()
6344 }
6345}
6346impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6347 for FrbWrapper<crate::bindings::MessageSuccessActionData>
6348{
6349}
6350impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::MessageSuccessActionData>>
6351 for crate::bindings::MessageSuccessActionData
6352{
6353 fn into_into_dart(self) -> FrbWrapper<crate::bindings::MessageSuccessActionData> {
6354 self.into()
6355 }
6356}
6357impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Network> {
6359 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6360 match self.0 {
6361 crate::bindings::Network::Bitcoin => 0.into_dart(),
6362 crate::bindings::Network::Testnet => 1.into_dart(),
6363 crate::bindings::Network::Signet => 2.into_dart(),
6364 crate::bindings::Network::Regtest => 3.into_dart(),
6365 _ => unreachable!(),
6366 }
6367 }
6368}
6369impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6370 for FrbWrapper<crate::bindings::Network>
6371{
6372}
6373impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Network>>
6374 for crate::bindings::Network
6375{
6376 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Network> {
6377 self.into()
6378 }
6379}
6380impl flutter_rust_bridge::IntoDart for crate::model::OnchainPaymentLimitsResponse {
6382 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6383 [
6384 self.send.into_into_dart().into_dart(),
6385 self.receive.into_into_dart().into_dart(),
6386 ]
6387 .into_dart()
6388 }
6389}
6390impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6391 for crate::model::OnchainPaymentLimitsResponse
6392{
6393}
6394impl flutter_rust_bridge::IntoIntoDart<crate::model::OnchainPaymentLimitsResponse>
6395 for crate::model::OnchainPaymentLimitsResponse
6396{
6397 fn into_into_dart(self) -> crate::model::OnchainPaymentLimitsResponse {
6398 self
6399 }
6400}
6401impl flutter_rust_bridge::IntoDart for crate::model::PayAmount {
6403 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6404 match self {
6405 crate::model::PayAmount::Bitcoin {
6406 receiver_amount_sat,
6407 } => [
6408 0.into_dart(),
6409 receiver_amount_sat.into_into_dart().into_dart(),
6410 ]
6411 .into_dart(),
6412 crate::model::PayAmount::Asset {
6413 to_asset,
6414 receiver_amount,
6415 estimate_asset_fees,
6416 from_asset,
6417 } => [
6418 1.into_dart(),
6419 to_asset.into_into_dart().into_dart(),
6420 receiver_amount.into_into_dart().into_dart(),
6421 estimate_asset_fees.into_into_dart().into_dart(),
6422 from_asset.into_into_dart().into_dart(),
6423 ]
6424 .into_dart(),
6425 crate::model::PayAmount::Drain => [2.into_dart()].into_dart(),
6426 _ => {
6427 unimplemented!("");
6428 }
6429 }
6430 }
6431}
6432impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PayAmount {}
6433impl flutter_rust_bridge::IntoIntoDart<crate::model::PayAmount> for crate::model::PayAmount {
6434 fn into_into_dart(self) -> crate::model::PayAmount {
6435 self
6436 }
6437}
6438impl flutter_rust_bridge::IntoDart for crate::model::PayOnchainRequest {
6440 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6441 [
6442 self.address.into_into_dart().into_dart(),
6443 self.prepare_response.into_into_dart().into_dart(),
6444 ]
6445 .into_dart()
6446 }
6447}
6448impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6449 for crate::model::PayOnchainRequest
6450{
6451}
6452impl flutter_rust_bridge::IntoIntoDart<crate::model::PayOnchainRequest>
6453 for crate::model::PayOnchainRequest
6454{
6455 fn into_into_dart(self) -> crate::model::PayOnchainRequest {
6456 self
6457 }
6458}
6459impl flutter_rust_bridge::IntoDart for crate::model::Payment {
6461 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6462 [
6463 self.destination.into_into_dart().into_dart(),
6464 self.tx_id.into_into_dart().into_dart(),
6465 self.unblinding_data.into_into_dart().into_dart(),
6466 self.timestamp.into_into_dart().into_dart(),
6467 self.amount_sat.into_into_dart().into_dart(),
6468 self.fees_sat.into_into_dart().into_dart(),
6469 self.swapper_fees_sat.into_into_dart().into_dart(),
6470 self.payment_type.into_into_dart().into_dart(),
6471 self.status.into_into_dart().into_dart(),
6472 self.details.into_into_dart().into_dart(),
6473 ]
6474 .into_dart()
6475 }
6476}
6477impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Payment {}
6478impl flutter_rust_bridge::IntoIntoDart<crate::model::Payment> for crate::model::Payment {
6479 fn into_into_dart(self) -> crate::model::Payment {
6480 self
6481 }
6482}
6483impl flutter_rust_bridge::IntoDart for crate::model::PaymentDetails {
6485 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6486 match self {
6487 crate::model::PaymentDetails::Lightning {
6488 swap_id,
6489 description,
6490 liquid_expiration_blockheight,
6491 preimage,
6492 invoice,
6493 bolt12_offer,
6494 payment_hash,
6495 destination_pubkey,
6496 lnurl_info,
6497 bip353_address,
6498 payer_note,
6499 claim_tx_id,
6500 refund_tx_id,
6501 refund_tx_amount_sat,
6502 } => [
6503 0.into_dart(),
6504 swap_id.into_into_dart().into_dart(),
6505 description.into_into_dart().into_dart(),
6506 liquid_expiration_blockheight.into_into_dart().into_dart(),
6507 preimage.into_into_dart().into_dart(),
6508 invoice.into_into_dart().into_dart(),
6509 bolt12_offer.into_into_dart().into_dart(),
6510 payment_hash.into_into_dart().into_dart(),
6511 destination_pubkey.into_into_dart().into_dart(),
6512 lnurl_info.into_into_dart().into_dart(),
6513 bip353_address.into_into_dart().into_dart(),
6514 payer_note.into_into_dart().into_dart(),
6515 claim_tx_id.into_into_dart().into_dart(),
6516 refund_tx_id.into_into_dart().into_dart(),
6517 refund_tx_amount_sat.into_into_dart().into_dart(),
6518 ]
6519 .into_dart(),
6520 crate::model::PaymentDetails::Liquid {
6521 destination,
6522 description,
6523 asset_id,
6524 asset_info,
6525 lnurl_info,
6526 bip353_address,
6527 payer_note,
6528 } => [
6529 1.into_dart(),
6530 destination.into_into_dart().into_dart(),
6531 description.into_into_dart().into_dart(),
6532 asset_id.into_into_dart().into_dart(),
6533 asset_info.into_into_dart().into_dart(),
6534 lnurl_info.into_into_dart().into_dart(),
6535 bip353_address.into_into_dart().into_dart(),
6536 payer_note.into_into_dart().into_dart(),
6537 ]
6538 .into_dart(),
6539 crate::model::PaymentDetails::Bitcoin {
6540 swap_id,
6541 bitcoin_address,
6542 description,
6543 auto_accepted_fees,
6544 liquid_expiration_blockheight,
6545 bitcoin_expiration_blockheight,
6546 lockup_tx_id,
6547 claim_tx_id,
6548 refund_tx_id,
6549 refund_tx_amount_sat,
6550 } => [
6551 2.into_dart(),
6552 swap_id.into_into_dart().into_dart(),
6553 bitcoin_address.into_into_dart().into_dart(),
6554 description.into_into_dart().into_dart(),
6555 auto_accepted_fees.into_into_dart().into_dart(),
6556 liquid_expiration_blockheight.into_into_dart().into_dart(),
6557 bitcoin_expiration_blockheight.into_into_dart().into_dart(),
6558 lockup_tx_id.into_into_dart().into_dart(),
6559 claim_tx_id.into_into_dart().into_dart(),
6560 refund_tx_id.into_into_dart().into_dart(),
6561 refund_tx_amount_sat.into_into_dart().into_dart(),
6562 ]
6563 .into_dart(),
6564 _ => {
6565 unimplemented!("");
6566 }
6567 }
6568 }
6569}
6570impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentDetails {}
6571impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentDetails>
6572 for crate::model::PaymentDetails
6573{
6574 fn into_into_dart(self) -> crate::model::PaymentDetails {
6575 self
6576 }
6577}
6578impl flutter_rust_bridge::IntoDart for crate::error::PaymentError {
6580 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6581 match self {
6582 crate::error::PaymentError::AlreadyClaimed => [0.into_dart()].into_dart(),
6583 crate::error::PaymentError::AlreadyPaid => [1.into_dart()].into_dart(),
6584 crate::error::PaymentError::PaymentInProgress => [2.into_dart()].into_dart(),
6585 crate::error::PaymentError::AmountOutOfRange { min, max } => [
6586 3.into_dart(),
6587 min.into_into_dart().into_dart(),
6588 max.into_into_dart().into_dart(),
6589 ]
6590 .into_dart(),
6591 crate::error::PaymentError::AmountMissing { err } => {
6592 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6593 }
6594 crate::error::PaymentError::AssetError { err } => {
6595 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6596 }
6597 crate::error::PaymentError::InvalidNetwork { err } => {
6598 [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
6599 }
6600 crate::error::PaymentError::Generic { err } => {
6601 [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
6602 }
6603 crate::error::PaymentError::InvalidOrExpiredFees => [8.into_dart()].into_dart(),
6604 crate::error::PaymentError::InsufficientFunds => [9.into_dart()].into_dart(),
6605 crate::error::PaymentError::InvalidDescription { err } => {
6606 [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6607 }
6608 crate::error::PaymentError::InvalidInvoice { err } => {
6609 [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6610 }
6611 crate::error::PaymentError::InvalidPreimage => [12.into_dart()].into_dart(),
6612 crate::error::PaymentError::PairsNotFound => [13.into_dart()].into_dart(),
6613 crate::error::PaymentError::PaymentTimeout => [14.into_dart()].into_dart(),
6614 crate::error::PaymentError::PersistError => [15.into_dart()].into_dart(),
6615 crate::error::PaymentError::ReceiveError { err } => {
6616 [16.into_dart(), err.into_into_dart().into_dart()].into_dart()
6617 }
6618 crate::error::PaymentError::Refunded { err, refund_tx_id } => [
6619 17.into_dart(),
6620 err.into_into_dart().into_dart(),
6621 refund_tx_id.into_into_dart().into_dart(),
6622 ]
6623 .into_dart(),
6624 crate::error::PaymentError::SelfTransferNotSupported => [18.into_dart()].into_dart(),
6625 crate::error::PaymentError::SendError { err } => {
6626 [19.into_dart(), err.into_into_dart().into_dart()].into_dart()
6627 }
6628 crate::error::PaymentError::SignerError { err } => {
6629 [20.into_dart(), err.into_into_dart().into_dart()].into_dart()
6630 }
6631 _ => {
6632 unimplemented!("");
6633 }
6634 }
6635 }
6636}
6637impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::PaymentError {}
6638impl flutter_rust_bridge::IntoIntoDart<crate::error::PaymentError> for crate::error::PaymentError {
6639 fn into_into_dart(self) -> crate::error::PaymentError {
6640 self
6641 }
6642}
6643impl flutter_rust_bridge::IntoDart for crate::model::PaymentMethod {
6645 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6646 match self {
6647 Self::Lightning => 0.into_dart(),
6648 Self::Bolt11Invoice => 1.into_dart(),
6649 Self::Bolt12Offer => 2.into_dart(),
6650 Self::BitcoinAddress => 3.into_dart(),
6651 Self::LiquidAddress => 4.into_dart(),
6652 _ => unreachable!(),
6653 }
6654 }
6655}
6656impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentMethod {}
6657impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentMethod>
6658 for crate::model::PaymentMethod
6659{
6660 fn into_into_dart(self) -> crate::model::PaymentMethod {
6661 self
6662 }
6663}
6664impl flutter_rust_bridge::IntoDart for crate::model::PaymentState {
6666 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6667 match self {
6668 Self::Created => 0.into_dart(),
6669 Self::Pending => 1.into_dart(),
6670 Self::Complete => 2.into_dart(),
6671 Self::Failed => 3.into_dart(),
6672 Self::TimedOut => 4.into_dart(),
6673 Self::Refundable => 5.into_dart(),
6674 Self::RefundPending => 6.into_dart(),
6675 Self::WaitingFeeAcceptance => 7.into_dart(),
6676 _ => unreachable!(),
6677 }
6678 }
6679}
6680impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentState {}
6681impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentState> for crate::model::PaymentState {
6682 fn into_into_dart(self) -> crate::model::PaymentState {
6683 self
6684 }
6685}
6686impl flutter_rust_bridge::IntoDart for crate::model::PaymentType {
6688 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6689 match self {
6690 Self::Receive => 0.into_dart(),
6691 Self::Send => 1.into_dart(),
6692 _ => unreachable!(),
6693 }
6694 }
6695}
6696impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentType {}
6697impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentType> for crate::model::PaymentType {
6698 fn into_into_dart(self) -> crate::model::PaymentType {
6699 self
6700 }
6701}
6702impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinRequest {
6704 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6705 [
6706 self.provider.into_into_dart().into_dart(),
6707 self.amount_sat.into_into_dart().into_dart(),
6708 ]
6709 .into_dart()
6710 }
6711}
6712impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6713 for crate::model::PrepareBuyBitcoinRequest
6714{
6715}
6716impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinRequest>
6717 for crate::model::PrepareBuyBitcoinRequest
6718{
6719 fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinRequest {
6720 self
6721 }
6722}
6723impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinResponse {
6725 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6726 [
6727 self.provider.into_into_dart().into_dart(),
6728 self.amount_sat.into_into_dart().into_dart(),
6729 self.fees_sat.into_into_dart().into_dart(),
6730 ]
6731 .into_dart()
6732 }
6733}
6734impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6735 for crate::model::PrepareBuyBitcoinResponse
6736{
6737}
6738impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinResponse>
6739 for crate::model::PrepareBuyBitcoinResponse
6740{
6741 fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinResponse {
6742 self
6743 }
6744}
6745impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayRequest {
6747 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6748 [
6749 self.data.into_into_dart().into_dart(),
6750 self.amount.into_into_dart().into_dart(),
6751 self.bip353_address.into_into_dart().into_dart(),
6752 self.comment.into_into_dart().into_dart(),
6753 self.validate_success_action_url
6754 .into_into_dart()
6755 .into_dart(),
6756 ]
6757 .into_dart()
6758 }
6759}
6760impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6761 for crate::model::PrepareLnUrlPayRequest
6762{
6763}
6764impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayRequest>
6765 for crate::model::PrepareLnUrlPayRequest
6766{
6767 fn into_into_dart(self) -> crate::model::PrepareLnUrlPayRequest {
6768 self
6769 }
6770}
6771impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayResponse {
6773 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6774 [
6775 self.destination.into_into_dart().into_dart(),
6776 self.fees_sat.into_into_dart().into_dart(),
6777 self.data.into_into_dart().into_dart(),
6778 self.amount.into_into_dart().into_dart(),
6779 self.comment.into_into_dart().into_dart(),
6780 self.success_action.into_into_dart().into_dart(),
6781 ]
6782 .into_dart()
6783 }
6784}
6785impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6786 for crate::model::PrepareLnUrlPayResponse
6787{
6788}
6789impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayResponse>
6790 for crate::model::PrepareLnUrlPayResponse
6791{
6792 fn into_into_dart(self) -> crate::model::PrepareLnUrlPayResponse {
6793 self
6794 }
6795}
6796impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainRequest {
6798 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6799 [
6800 self.amount.into_into_dart().into_dart(),
6801 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6802 ]
6803 .into_dart()
6804 }
6805}
6806impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6807 for crate::model::PreparePayOnchainRequest
6808{
6809}
6810impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainRequest>
6811 for crate::model::PreparePayOnchainRequest
6812{
6813 fn into_into_dart(self) -> crate::model::PreparePayOnchainRequest {
6814 self
6815 }
6816}
6817impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainResponse {
6819 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6820 [
6821 self.receiver_amount_sat.into_into_dart().into_dart(),
6822 self.claim_fees_sat.into_into_dart().into_dart(),
6823 self.total_fees_sat.into_into_dart().into_dart(),
6824 ]
6825 .into_dart()
6826 }
6827}
6828impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6829 for crate::model::PreparePayOnchainResponse
6830{
6831}
6832impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainResponse>
6833 for crate::model::PreparePayOnchainResponse
6834{
6835 fn into_into_dart(self) -> crate::model::PreparePayOnchainResponse {
6836 self
6837 }
6838}
6839impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveRequest {
6841 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6842 [
6843 self.payment_method.into_into_dart().into_dart(),
6844 self.amount.into_into_dart().into_dart(),
6845 ]
6846 .into_dart()
6847 }
6848}
6849impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6850 for crate::model::PrepareReceiveRequest
6851{
6852}
6853impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveRequest>
6854 for crate::model::PrepareReceiveRequest
6855{
6856 fn into_into_dart(self) -> crate::model::PrepareReceiveRequest {
6857 self
6858 }
6859}
6860impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveResponse {
6862 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6863 [
6864 self.payment_method.into_into_dart().into_dart(),
6865 self.fees_sat.into_into_dart().into_dart(),
6866 self.amount.into_into_dart().into_dart(),
6867 self.min_payer_amount_sat.into_into_dart().into_dart(),
6868 self.max_payer_amount_sat.into_into_dart().into_dart(),
6869 self.swapper_feerate.into_into_dart().into_dart(),
6870 ]
6871 .into_dart()
6872 }
6873}
6874impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6875 for crate::model::PrepareReceiveResponse
6876{
6877}
6878impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveResponse>
6879 for crate::model::PrepareReceiveResponse
6880{
6881 fn into_into_dart(self) -> crate::model::PrepareReceiveResponse {
6882 self
6883 }
6884}
6885impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundRequest {
6887 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6888 [
6889 self.swap_address.into_into_dart().into_dart(),
6890 self.refund_address.into_into_dart().into_dart(),
6891 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6892 ]
6893 .into_dart()
6894 }
6895}
6896impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6897 for crate::model::PrepareRefundRequest
6898{
6899}
6900impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundRequest>
6901 for crate::model::PrepareRefundRequest
6902{
6903 fn into_into_dart(self) -> crate::model::PrepareRefundRequest {
6904 self
6905 }
6906}
6907impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundResponse {
6909 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6910 [
6911 self.tx_vsize.into_into_dart().into_dart(),
6912 self.tx_fee_sat.into_into_dart().into_dart(),
6913 self.last_refund_tx_id.into_into_dart().into_dart(),
6914 ]
6915 .into_dart()
6916 }
6917}
6918impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6919 for crate::model::PrepareRefundResponse
6920{
6921}
6922impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundResponse>
6923 for crate::model::PrepareRefundResponse
6924{
6925 fn into_into_dart(self) -> crate::model::PrepareRefundResponse {
6926 self
6927 }
6928}
6929impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendRequest {
6931 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6932 [
6933 self.destination.into_into_dart().into_dart(),
6934 self.amount.into_into_dart().into_dart(),
6935 ]
6936 .into_dart()
6937 }
6938}
6939impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6940 for crate::model::PrepareSendRequest
6941{
6942}
6943impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendRequest>
6944 for crate::model::PrepareSendRequest
6945{
6946 fn into_into_dart(self) -> crate::model::PrepareSendRequest {
6947 self
6948 }
6949}
6950impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendResponse {
6952 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6953 [
6954 self.destination.into_into_dart().into_dart(),
6955 self.amount.into_into_dart().into_dart(),
6956 self.fees_sat.into_into_dart().into_dart(),
6957 self.estimated_asset_fees.into_into_dart().into_dart(),
6958 self.exchange_amount_sat.into_into_dart().into_dart(),
6959 ]
6960 .into_dart()
6961 }
6962}
6963impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6964 for crate::model::PrepareSendResponse
6965{
6966}
6967impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendResponse>
6968 for crate::model::PrepareSendResponse
6969{
6970 fn into_into_dart(self) -> crate::model::PrepareSendResponse {
6971 self
6972 }
6973}
6974impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Rate> {
6976 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6977 [
6978 self.0.coin.into_into_dart().into_dart(),
6979 self.0.value.into_into_dart().into_dart(),
6980 ]
6981 .into_dart()
6982 }
6983}
6984impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6985 for FrbWrapper<crate::bindings::Rate>
6986{
6987}
6988impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Rate>>
6989 for crate::bindings::Rate
6990{
6991 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Rate> {
6992 self.into()
6993 }
6994}
6995impl flutter_rust_bridge::IntoDart for crate::model::ReceiveAmount {
6997 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6998 match self {
6999 crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
7000 [0.into_dart(), payer_amount_sat.into_into_dart().into_dart()].into_dart()
7001 }
7002 crate::model::ReceiveAmount::Asset {
7003 asset_id,
7004 payer_amount,
7005 } => [
7006 1.into_dart(),
7007 asset_id.into_into_dart().into_dart(),
7008 payer_amount.into_into_dart().into_dart(),
7009 ]
7010 .into_dart(),
7011 _ => {
7012 unimplemented!("");
7013 }
7014 }
7015 }
7016}
7017impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ReceiveAmount {}
7018impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceiveAmount>
7019 for crate::model::ReceiveAmount
7020{
7021 fn into_into_dart(self) -> crate::model::ReceiveAmount {
7022 self
7023 }
7024}
7025impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentRequest {
7027 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7028 [
7029 self.prepare_response.into_into_dart().into_dart(),
7030 self.description.into_into_dart().into_dart(),
7031 self.use_description_hash.into_into_dart().into_dart(),
7032 self.payer_note.into_into_dart().into_dart(),
7033 ]
7034 .into_dart()
7035 }
7036}
7037impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7038 for crate::model::ReceivePaymentRequest
7039{
7040}
7041impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentRequest>
7042 for crate::model::ReceivePaymentRequest
7043{
7044 fn into_into_dart(self) -> crate::model::ReceivePaymentRequest {
7045 self
7046 }
7047}
7048impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentResponse {
7050 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7051 [
7052 self.destination.into_into_dart().into_dart(),
7053 self.liquid_expiration_blockheight
7054 .into_into_dart()
7055 .into_dart(),
7056 self.bitcoin_expiration_blockheight
7057 .into_into_dart()
7058 .into_dart(),
7059 ]
7060 .into_dart()
7061 }
7062}
7063impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7064 for crate::model::ReceivePaymentResponse
7065{
7066}
7067impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentResponse>
7068 for crate::model::ReceivePaymentResponse
7069{
7070 fn into_into_dart(self) -> crate::model::ReceivePaymentResponse {
7071 self
7072 }
7073}
7074impl flutter_rust_bridge::IntoDart for crate::model::RecommendedFees {
7076 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7077 [
7078 self.fastest_fee.into_into_dart().into_dart(),
7079 self.half_hour_fee.into_into_dart().into_dart(),
7080 self.hour_fee.into_into_dart().into_dart(),
7081 self.economy_fee.into_into_dart().into_dart(),
7082 self.minimum_fee.into_into_dart().into_dart(),
7083 ]
7084 .into_dart()
7085 }
7086}
7087impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RecommendedFees {}
7088impl flutter_rust_bridge::IntoIntoDart<crate::model::RecommendedFees>
7089 for crate::model::RecommendedFees
7090{
7091 fn into_into_dart(self) -> crate::model::RecommendedFees {
7092 self
7093 }
7094}
7095impl flutter_rust_bridge::IntoDart for crate::model::RefundRequest {
7097 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7098 [
7099 self.swap_address.into_into_dart().into_dart(),
7100 self.refund_address.into_into_dart().into_dart(),
7101 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
7102 ]
7103 .into_dart()
7104 }
7105}
7106impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundRequest {}
7107impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundRequest>
7108 for crate::model::RefundRequest
7109{
7110 fn into_into_dart(self) -> crate::model::RefundRequest {
7111 self
7112 }
7113}
7114impl flutter_rust_bridge::IntoDart for crate::model::RefundResponse {
7116 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7117 [self.refund_tx_id.into_into_dart().into_dart()].into_dart()
7118 }
7119}
7120impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundResponse {}
7121impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundResponse>
7122 for crate::model::RefundResponse
7123{
7124 fn into_into_dart(self) -> crate::model::RefundResponse {
7125 self
7126 }
7127}
7128impl flutter_rust_bridge::IntoDart for crate::model::RefundableSwap {
7130 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7131 [
7132 self.swap_address.into_into_dart().into_dart(),
7133 self.timestamp.into_into_dart().into_dart(),
7134 self.amount_sat.into_into_dart().into_dart(),
7135 self.last_refund_tx_id.into_into_dart().into_dart(),
7136 ]
7137 .into_dart()
7138 }
7139}
7140impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundableSwap {}
7141impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundableSwap>
7142 for crate::model::RefundableSwap
7143{
7144 fn into_into_dart(self) -> crate::model::RefundableSwap {
7145 self
7146 }
7147}
7148impl flutter_rust_bridge::IntoDart for crate::model::RestoreRequest {
7150 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7151 [self.backup_path.into_into_dart().into_dart()].into_dart()
7152 }
7153}
7154impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RestoreRequest {}
7155impl flutter_rust_bridge::IntoIntoDart<crate::model::RestoreRequest>
7156 for crate::model::RestoreRequest
7157{
7158 fn into_into_dart(self) -> crate::model::RestoreRequest {
7159 self
7160 }
7161}
7162impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHint> {
7164 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7165 [self.0.hops.into_into_dart().into_dart()].into_dart()
7166 }
7167}
7168impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7169 for FrbWrapper<crate::bindings::RouteHint>
7170{
7171}
7172impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHint>>
7173 for crate::bindings::RouteHint
7174{
7175 fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHint> {
7176 self.into()
7177 }
7178}
7179impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHintHop> {
7181 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7182 [
7183 self.0.src_node_id.into_into_dart().into_dart(),
7184 self.0.short_channel_id.into_into_dart().into_dart(),
7185 self.0.fees_base_msat.into_into_dart().into_dart(),
7186 self.0
7187 .fees_proportional_millionths
7188 .into_into_dart()
7189 .into_dart(),
7190 self.0.cltv_expiry_delta.into_into_dart().into_dart(),
7191 self.0.htlc_minimum_msat.into_into_dart().into_dart(),
7192 self.0.htlc_maximum_msat.into_into_dart().into_dart(),
7193 ]
7194 .into_dart()
7195 }
7196}
7197impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7198 for FrbWrapper<crate::bindings::RouteHintHop>
7199{
7200}
7201impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHintHop>>
7202 for crate::bindings::RouteHintHop
7203{
7204 fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHintHop> {
7205 self.into()
7206 }
7207}
7208impl flutter_rust_bridge::IntoDart for crate::error::SdkError {
7210 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7211 match self {
7212 crate::error::SdkError::AlreadyStarted => [0.into_dart()].into_dart(),
7213 crate::error::SdkError::Generic { err } => {
7214 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
7215 }
7216 crate::error::SdkError::NotStarted => [2.into_dart()].into_dart(),
7217 crate::error::SdkError::ServiceConnectivity { err } => {
7218 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
7219 }
7220 _ => {
7221 unimplemented!("");
7222 }
7223 }
7224 }
7225}
7226impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::SdkError {}
7227impl flutter_rust_bridge::IntoIntoDart<crate::error::SdkError> for crate::error::SdkError {
7228 fn into_into_dart(self) -> crate::error::SdkError {
7229 self
7230 }
7231}
7232impl flutter_rust_bridge::IntoDart for crate::model::SdkEvent {
7234 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7235 match self {
7236 crate::model::SdkEvent::PaymentFailed { details } => {
7237 [0.into_dart(), details.into_into_dart().into_dart()].into_dart()
7238 }
7239 crate::model::SdkEvent::PaymentPending { details } => {
7240 [1.into_dart(), details.into_into_dart().into_dart()].into_dart()
7241 }
7242 crate::model::SdkEvent::PaymentRefundable { details } => {
7243 [2.into_dart(), details.into_into_dart().into_dart()].into_dart()
7244 }
7245 crate::model::SdkEvent::PaymentRefunded { details } => {
7246 [3.into_dart(), details.into_into_dart().into_dart()].into_dart()
7247 }
7248 crate::model::SdkEvent::PaymentRefundPending { details } => {
7249 [4.into_dart(), details.into_into_dart().into_dart()].into_dart()
7250 }
7251 crate::model::SdkEvent::PaymentSucceeded { details } => {
7252 [5.into_dart(), details.into_into_dart().into_dart()].into_dart()
7253 }
7254 crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
7255 [6.into_dart(), details.into_into_dart().into_dart()].into_dart()
7256 }
7257 crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
7258 [7.into_dart(), details.into_into_dart().into_dart()].into_dart()
7259 }
7260 crate::model::SdkEvent::Synced => [8.into_dart()].into_dart(),
7261 crate::model::SdkEvent::DataSynced {
7262 did_pull_new_records,
7263 } => [
7264 9.into_dart(),
7265 did_pull_new_records.into_into_dart().into_dart(),
7266 ]
7267 .into_dart(),
7268 _ => {
7269 unimplemented!("");
7270 }
7271 }
7272 }
7273}
7274impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SdkEvent {}
7275impl flutter_rust_bridge::IntoIntoDart<crate::model::SdkEvent> for crate::model::SdkEvent {
7276 fn into_into_dart(self) -> crate::model::SdkEvent {
7277 self
7278 }
7279}
7280impl flutter_rust_bridge::IntoDart for crate::model::SendDestination {
7282 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7283 match self {
7284 crate::model::SendDestination::LiquidAddress {
7285 address_data,
7286 bip353_address,
7287 } => [
7288 0.into_dart(),
7289 address_data.into_into_dart().into_dart(),
7290 bip353_address.into_into_dart().into_dart(),
7291 ]
7292 .into_dart(),
7293 crate::model::SendDestination::Bolt11 {
7294 invoice,
7295 bip353_address,
7296 } => [
7297 1.into_dart(),
7298 invoice.into_into_dart().into_dart(),
7299 bip353_address.into_into_dart().into_dart(),
7300 ]
7301 .into_dart(),
7302 crate::model::SendDestination::Bolt12 {
7303 offer,
7304 receiver_amount_sat,
7305 bip353_address,
7306 } => [
7307 2.into_dart(),
7308 offer.into_into_dart().into_dart(),
7309 receiver_amount_sat.into_into_dart().into_dart(),
7310 bip353_address.into_into_dart().into_dart(),
7311 ]
7312 .into_dart(),
7313 _ => {
7314 unimplemented!("");
7315 }
7316 }
7317 }
7318}
7319impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SendDestination {}
7320impl flutter_rust_bridge::IntoIntoDart<crate::model::SendDestination>
7321 for crate::model::SendDestination
7322{
7323 fn into_into_dart(self) -> crate::model::SendDestination {
7324 self
7325 }
7326}
7327impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentRequest {
7329 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7330 [
7331 self.prepare_response.into_into_dart().into_dart(),
7332 self.use_asset_fees.into_into_dart().into_dart(),
7333 self.payer_note.into_into_dart().into_dart(),
7334 ]
7335 .into_dart()
7336 }
7337}
7338impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7339 for crate::model::SendPaymentRequest
7340{
7341}
7342impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentRequest>
7343 for crate::model::SendPaymentRequest
7344{
7345 fn into_into_dart(self) -> crate::model::SendPaymentRequest {
7346 self
7347 }
7348}
7349impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentResponse {
7351 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7352 [self.payment.into_into_dart().into_dart()].into_dart()
7353 }
7354}
7355impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7356 for crate::model::SendPaymentResponse
7357{
7358}
7359impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentResponse>
7360 for crate::model::SendPaymentResponse
7361{
7362 fn into_into_dart(self) -> crate::model::SendPaymentResponse {
7363 self
7364 }
7365}
7366impl flutter_rust_bridge::IntoDart for crate::model::SignMessageRequest {
7368 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7369 [self.message.into_into_dart().into_dart()].into_dart()
7370 }
7371}
7372impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7373 for crate::model::SignMessageRequest
7374{
7375}
7376impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageRequest>
7377 for crate::model::SignMessageRequest
7378{
7379 fn into_into_dart(self) -> crate::model::SignMessageRequest {
7380 self
7381 }
7382}
7383impl flutter_rust_bridge::IntoDart for crate::model::SignMessageResponse {
7385 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7386 [self.signature.into_into_dart().into_dart()].into_dart()
7387 }
7388}
7389impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7390 for crate::model::SignMessageResponse
7391{
7392}
7393impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageResponse>
7394 for crate::model::SignMessageResponse
7395{
7396 fn into_into_dart(self) -> crate::model::SignMessageResponse {
7397 self
7398 }
7399}
7400impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessAction> {
7402 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7403 match self.0 {
7404 crate::bindings::SuccessAction::Aes { data } => {
7405 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
7406 }
7407 crate::bindings::SuccessAction::Message { data } => {
7408 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7409 }
7410 crate::bindings::SuccessAction::Url { data } => {
7411 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7412 }
7413 _ => {
7414 unimplemented!("");
7415 }
7416 }
7417 }
7418}
7419impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7420 for FrbWrapper<crate::bindings::SuccessAction>
7421{
7422}
7423impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessAction>>
7424 for crate::bindings::SuccessAction
7425{
7426 fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessAction> {
7427 self.into()
7428 }
7429}
7430impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessActionProcessed> {
7432 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7433 match self.0 {
7434 crate::bindings::SuccessActionProcessed::Aes { result } => {
7435 [0.into_dart(), result.into_into_dart().into_dart()].into_dart()
7436 }
7437 crate::bindings::SuccessActionProcessed::Message { data } => {
7438 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7439 }
7440 crate::bindings::SuccessActionProcessed::Url { data } => {
7441 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7442 }
7443 _ => {
7444 unimplemented!("");
7445 }
7446 }
7447 }
7448}
7449impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7450 for FrbWrapper<crate::bindings::SuccessActionProcessed>
7451{
7452}
7453impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessActionProcessed>>
7454 for crate::bindings::SuccessActionProcessed
7455{
7456 fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessActionProcessed> {
7457 self.into()
7458 }
7459}
7460impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Symbol> {
7462 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7463 [
7464 self.0.grapheme.into_into_dart().into_dart(),
7465 self.0.template.into_into_dart().into_dart(),
7466 self.0.rtl.into_into_dart().into_dart(),
7467 self.0.position.into_into_dart().into_dart(),
7468 ]
7469 .into_dart()
7470 }
7471}
7472impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7473 for FrbWrapper<crate::bindings::Symbol>
7474{
7475}
7476impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Symbol>>
7477 for crate::bindings::Symbol
7478{
7479 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Symbol> {
7480 self.into()
7481 }
7482}
7483impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::UrlSuccessActionData> {
7485 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7486 [
7487 self.0.description.into_into_dart().into_dart(),
7488 self.0.url.into_into_dart().into_dart(),
7489 self.0.matches_callback_domain.into_into_dart().into_dart(),
7490 ]
7491 .into_dart()
7492 }
7493}
7494impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7495 for FrbWrapper<crate::bindings::UrlSuccessActionData>
7496{
7497}
7498impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::UrlSuccessActionData>>
7499 for crate::bindings::UrlSuccessActionData
7500{
7501 fn into_into_dart(self) -> FrbWrapper<crate::bindings::UrlSuccessActionData> {
7502 self.into()
7503 }
7504}
7505impl flutter_rust_bridge::IntoDart for crate::model::WalletInfo {
7507 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7508 [
7509 self.balance_sat.into_into_dart().into_dart(),
7510 self.pending_send_sat.into_into_dart().into_dart(),
7511 self.pending_receive_sat.into_into_dart().into_dart(),
7512 self.fingerprint.into_into_dart().into_dart(),
7513 self.pubkey.into_into_dart().into_dart(),
7514 self.asset_balances.into_into_dart().into_dart(),
7515 ]
7516 .into_dart()
7517 }
7518}
7519impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::WalletInfo {}
7520impl flutter_rust_bridge::IntoIntoDart<crate::model::WalletInfo> for crate::model::WalletInfo {
7521 fn into_into_dart(self) -> crate::model::WalletInfo {
7522 self
7523 }
7524}
7525
7526impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
7527 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7529 <String>::sse_encode(format!("{:?}", self), serializer);
7530 }
7531}
7532
7533impl SseEncode for BindingLiquidSdk {
7534 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7536 <RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer);
7537 }
7538}
7539
7540impl SseEncode
7541 for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
7542{
7543 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7545 let (ptr, size) = self.sse_encode_raw();
7546 <usize>::sse_encode(ptr, serializer);
7547 <i32>::sse_encode(size, serializer);
7548 }
7549}
7550
7551impl SseEncode
7552 for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
7553{
7554 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7556 unimplemented!("")
7557 }
7558}
7559
7560impl SseEncode
7561 for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
7562{
7563 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7565 unimplemented!("")
7566 }
7567}
7568
7569impl SseEncode for String {
7570 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7572 <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
7573 }
7574}
7575
7576impl SseEncode for crate::model::AcceptPaymentProposedFeesRequest {
7577 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7579 <crate::model::FetchPaymentProposedFeesResponse>::sse_encode(self.response, serializer);
7580 }
7581}
7582
7583impl SseEncode for crate::bindings::AesSuccessActionData {
7584 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7586 <String>::sse_encode(self.description, serializer);
7587 <String>::sse_encode(self.ciphertext, serializer);
7588 <String>::sse_encode(self.iv, serializer);
7589 }
7590}
7591
7592impl SseEncode for crate::bindings::AesSuccessActionDataDecrypted {
7593 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7595 <String>::sse_encode(self.description, serializer);
7596 <String>::sse_encode(self.plaintext, serializer);
7597 }
7598}
7599
7600impl SseEncode for crate::bindings::AesSuccessActionDataResult {
7601 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7603 match self {
7604 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
7605 <i32>::sse_encode(0, serializer);
7606 <crate::bindings::AesSuccessActionDataDecrypted>::sse_encode(data, serializer);
7607 }
7608 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
7609 <i32>::sse_encode(1, serializer);
7610 <String>::sse_encode(reason, serializer);
7611 }
7612 _ => {
7613 unimplemented!("");
7614 }
7615 }
7616 }
7617}
7618
7619impl SseEncode for crate::bindings::Amount {
7620 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7622 match self {
7623 crate::bindings::Amount::Bitcoin { amount_msat } => {
7624 <i32>::sse_encode(0, serializer);
7625 <u64>::sse_encode(amount_msat, serializer);
7626 }
7627 crate::bindings::Amount::Currency {
7628 iso4217_code,
7629 fractional_amount,
7630 } => {
7631 <i32>::sse_encode(1, serializer);
7632 <String>::sse_encode(iso4217_code, serializer);
7633 <u64>::sse_encode(fractional_amount, serializer);
7634 }
7635 _ => {
7636 unimplemented!("");
7637 }
7638 }
7639 }
7640}
7641
7642impl SseEncode for crate::model::AssetBalance {
7643 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7645 <String>::sse_encode(self.asset_id, serializer);
7646 <u64>::sse_encode(self.balance_sat, serializer);
7647 <Option<String>>::sse_encode(self.name, serializer);
7648 <Option<String>>::sse_encode(self.ticker, serializer);
7649 <Option<f64>>::sse_encode(self.balance, serializer);
7650 }
7651}
7652
7653impl SseEncode for crate::model::AssetInfo {
7654 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7656 <String>::sse_encode(self.name, serializer);
7657 <String>::sse_encode(self.ticker, serializer);
7658 <f64>::sse_encode(self.amount, serializer);
7659 <Option<f64>>::sse_encode(self.fees, serializer);
7660 }
7661}
7662
7663impl SseEncode for crate::model::AssetMetadata {
7664 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7666 <String>::sse_encode(self.asset_id, serializer);
7667 <String>::sse_encode(self.name, serializer);
7668 <String>::sse_encode(self.ticker, serializer);
7669 <u8>::sse_encode(self.precision, serializer);
7670 <Option<String>>::sse_encode(self.fiat_id, serializer);
7671 }
7672}
7673
7674impl SseEncode for crate::model::BackupRequest {
7675 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7677 <Option<String>>::sse_encode(self.backup_path, serializer);
7678 }
7679}
7680
7681impl SseEncode for crate::bindings::BindingEventListener {
7682 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7684 <StreamSink<crate::model::SdkEvent,flutter_rust_bridge::for_generated::DcoCodec>>::sse_encode(self.stream, serializer);
7685 }
7686}
7687
7688impl SseEncode for crate::bindings::BitcoinAddressData {
7689 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7691 <String>::sse_encode(self.address, serializer);
7692 <crate::bindings::Network>::sse_encode(self.network, serializer);
7693 <Option<u64>>::sse_encode(self.amount_sat, serializer);
7694 <Option<String>>::sse_encode(self.label, serializer);
7695 <Option<String>>::sse_encode(self.message, serializer);
7696 }
7697}
7698
7699impl SseEncode for crate::model::BlockchainExplorer {
7700 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7702 match self {
7703 crate::model::BlockchainExplorer::Electrum { url } => {
7704 <i32>::sse_encode(0, serializer);
7705 <String>::sse_encode(url, serializer);
7706 }
7707 crate::model::BlockchainExplorer::Esplora {
7708 url,
7709 use_waterfalls,
7710 } => {
7711 <i32>::sse_encode(1, serializer);
7712 <String>::sse_encode(url, serializer);
7713 <bool>::sse_encode(use_waterfalls, serializer);
7714 }
7715 _ => {
7716 unimplemented!("");
7717 }
7718 }
7719 }
7720}
7721
7722impl SseEncode for crate::model::BlockchainInfo {
7723 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7725 <u32>::sse_encode(self.liquid_tip, serializer);
7726 <u32>::sse_encode(self.bitcoin_tip, serializer);
7727 }
7728}
7729
7730impl SseEncode for bool {
7731 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7733 serializer.cursor.write_u8(self as _).unwrap();
7734 }
7735}
7736
7737impl SseEncode for crate::model::BuyBitcoinProvider {
7738 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7740 <i32>::sse_encode(
7741 match self {
7742 crate::model::BuyBitcoinProvider::Moonpay => 0,
7743 _ => {
7744 unimplemented!("");
7745 }
7746 },
7747 serializer,
7748 );
7749 }
7750}
7751
7752impl SseEncode for crate::model::BuyBitcoinRequest {
7753 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7755 <crate::model::PrepareBuyBitcoinResponse>::sse_encode(self.prepare_response, serializer);
7756 <Option<String>>::sse_encode(self.redirect_url, serializer);
7757 }
7758}
7759
7760impl SseEncode for crate::model::CheckMessageRequest {
7761 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7763 <String>::sse_encode(self.message, serializer);
7764 <String>::sse_encode(self.pubkey, serializer);
7765 <String>::sse_encode(self.signature, serializer);
7766 }
7767}
7768
7769impl SseEncode for crate::model::CheckMessageResponse {
7770 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7772 <bool>::sse_encode(self.is_valid, serializer);
7773 }
7774}
7775
7776impl SseEncode for crate::model::Config {
7777 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7779 <crate::model::BlockchainExplorer>::sse_encode(self.liquid_explorer, serializer);
7780 <crate::model::BlockchainExplorer>::sse_encode(self.bitcoin_explorer, serializer);
7781 <String>::sse_encode(self.working_dir, serializer);
7782 <crate::model::LiquidNetwork>::sse_encode(self.network, serializer);
7783 <u64>::sse_encode(self.payment_timeout_sec, serializer);
7784 <Option<String>>::sse_encode(self.sync_service_url, serializer);
7785 <Option<u64>>::sse_encode(self.zero_conf_max_amount_sat, serializer);
7786 <Option<String>>::sse_encode(self.breez_api_key, serializer);
7787 <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_encode(
7788 self.external_input_parsers,
7789 serializer,
7790 );
7791 <bool>::sse_encode(self.use_default_external_input_parsers, serializer);
7792 <Option<u64>>::sse_encode(self.onchain_fee_rate_leeway_sat, serializer);
7793 <Option<Vec<crate::model::AssetMetadata>>>::sse_encode(self.asset_metadata, serializer);
7794 <Option<String>>::sse_encode(self.sideswap_api_key, serializer);
7795 <bool>::sse_encode(self.use_magic_routing_hints, serializer);
7796 }
7797}
7798
7799impl SseEncode for crate::model::ConnectRequest {
7800 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7802 <crate::model::Config>::sse_encode(self.config, serializer);
7803 <Option<String>>::sse_encode(self.mnemonic, serializer);
7804 <Option<String>>::sse_encode(self.passphrase, serializer);
7805 <Option<Vec<u8>>>::sse_encode(self.seed, serializer);
7806 }
7807}
7808
7809impl SseEncode for crate::model::CreateBolt12InvoiceRequest {
7810 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7812 <String>::sse_encode(self.offer, serializer);
7813 <String>::sse_encode(self.invoice_request, serializer);
7814 }
7815}
7816
7817impl SseEncode for crate::model::CreateBolt12InvoiceResponse {
7818 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7820 <String>::sse_encode(self.invoice, serializer);
7821 }
7822}
7823
7824impl SseEncode for crate::bindings::CurrencyInfo {
7825 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7827 <String>::sse_encode(self.name, serializer);
7828 <u32>::sse_encode(self.fraction_size, serializer);
7829 <Option<u32>>::sse_encode(self.spacing, serializer);
7830 <Option<crate::bindings::Symbol>>::sse_encode(self.symbol, serializer);
7831 <Option<crate::bindings::Symbol>>::sse_encode(self.uniq_symbol, serializer);
7832 <Vec<crate::bindings::LocalizedName>>::sse_encode(self.localized_name, serializer);
7833 <Vec<crate::bindings::LocaleOverrides>>::sse_encode(self.locale_overrides, serializer);
7834 }
7835}
7836
7837impl SseEncode for crate::bindings::ExternalInputParser {
7838 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7840 <String>::sse_encode(self.provider_id, serializer);
7841 <String>::sse_encode(self.input_regex, serializer);
7842 <String>::sse_encode(self.parser_url, serializer);
7843 }
7844}
7845
7846impl SseEncode for f64 {
7847 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7849 serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
7850 }
7851}
7852
7853impl SseEncode for crate::model::FetchPaymentProposedFeesRequest {
7854 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7856 <String>::sse_encode(self.swap_id, serializer);
7857 }
7858}
7859
7860impl SseEncode for crate::model::FetchPaymentProposedFeesResponse {
7861 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7863 <String>::sse_encode(self.swap_id, serializer);
7864 <u64>::sse_encode(self.fees_sat, serializer);
7865 <u64>::sse_encode(self.payer_amount_sat, serializer);
7866 <u64>::sse_encode(self.receiver_amount_sat, serializer);
7867 }
7868}
7869
7870impl SseEncode for crate::bindings::FiatCurrency {
7871 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7873 <String>::sse_encode(self.id, serializer);
7874 <crate::bindings::CurrencyInfo>::sse_encode(self.info, serializer);
7875 }
7876}
7877
7878impl SseEncode for crate::model::GetInfoResponse {
7879 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7881 <crate::model::WalletInfo>::sse_encode(self.wallet_info, serializer);
7882 <crate::model::BlockchainInfo>::sse_encode(self.blockchain_info, serializer);
7883 }
7884}
7885
7886impl SseEncode for crate::model::GetPaymentRequest {
7887 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7889 match self {
7890 crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
7891 <i32>::sse_encode(0, serializer);
7892 <String>::sse_encode(payment_hash, serializer);
7893 }
7894 crate::model::GetPaymentRequest::SwapId { swap_id } => {
7895 <i32>::sse_encode(1, serializer);
7896 <String>::sse_encode(swap_id, serializer);
7897 }
7898 _ => {
7899 unimplemented!("");
7900 }
7901 }
7902 }
7903}
7904
7905impl SseEncode for i32 {
7906 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7908 serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
7909 }
7910}
7911
7912impl SseEncode for i64 {
7913 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7915 serializer.cursor.write_i64::<NativeEndian>(self).unwrap();
7916 }
7917}
7918
7919impl SseEncode for crate::bindings::InputType {
7920 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7922 match self {
7923 crate::bindings::InputType::BitcoinAddress { address } => {
7924 <i32>::sse_encode(0, serializer);
7925 <crate::bindings::BitcoinAddressData>::sse_encode(address, serializer);
7926 }
7927 crate::bindings::InputType::LiquidAddress { address } => {
7928 <i32>::sse_encode(1, serializer);
7929 <crate::bindings::LiquidAddressData>::sse_encode(address, serializer);
7930 }
7931 crate::bindings::InputType::Bolt11 { invoice } => {
7932 <i32>::sse_encode(2, serializer);
7933 <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
7934 }
7935 crate::bindings::InputType::Bolt12Offer {
7936 offer,
7937 bip353_address,
7938 } => {
7939 <i32>::sse_encode(3, serializer);
7940 <crate::bindings::LNOffer>::sse_encode(offer, serializer);
7941 <Option<String>>::sse_encode(bip353_address, serializer);
7942 }
7943 crate::bindings::InputType::NodeId { node_id } => {
7944 <i32>::sse_encode(4, serializer);
7945 <String>::sse_encode(node_id, serializer);
7946 }
7947 crate::bindings::InputType::Url { url } => {
7948 <i32>::sse_encode(5, serializer);
7949 <String>::sse_encode(url, serializer);
7950 }
7951 crate::bindings::InputType::LnUrlPay {
7952 data,
7953 bip353_address,
7954 } => {
7955 <i32>::sse_encode(6, serializer);
7956 <crate::bindings::LnUrlPayRequestData>::sse_encode(data, serializer);
7957 <Option<String>>::sse_encode(bip353_address, serializer);
7958 }
7959 crate::bindings::InputType::LnUrlWithdraw { data } => {
7960 <i32>::sse_encode(7, serializer);
7961 <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(data, serializer);
7962 }
7963 crate::bindings::InputType::LnUrlAuth { data } => {
7964 <i32>::sse_encode(8, serializer);
7965 <crate::bindings::LnUrlAuthRequestData>::sse_encode(data, serializer);
7966 }
7967 crate::bindings::InputType::LnUrlError { data } => {
7968 <i32>::sse_encode(9, serializer);
7969 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
7970 }
7971 _ => {
7972 unimplemented!("");
7973 }
7974 }
7975 }
7976}
7977
7978impl SseEncode for crate::model::LightningPaymentLimitsResponse {
7979 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7981 <crate::model::Limits>::sse_encode(self.send, serializer);
7982 <crate::model::Limits>::sse_encode(self.receive, serializer);
7983 }
7984}
7985
7986impl SseEncode for crate::model::Limits {
7987 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7989 <u64>::sse_encode(self.min_sat, serializer);
7990 <u64>::sse_encode(self.max_sat, serializer);
7991 <u64>::sse_encode(self.max_zero_conf_sat, serializer);
7992 }
7993}
7994
7995impl SseEncode for crate::bindings::LiquidAddressData {
7996 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7998 <String>::sse_encode(self.address, serializer);
7999 <crate::bindings::Network>::sse_encode(self.network, serializer);
8000 <Option<String>>::sse_encode(self.asset_id, serializer);
8001 <Option<f64>>::sse_encode(self.amount, serializer);
8002 <Option<u64>>::sse_encode(self.amount_sat, serializer);
8003 <Option<String>>::sse_encode(self.label, serializer);
8004 <Option<String>>::sse_encode(self.message, serializer);
8005 }
8006}
8007
8008impl SseEncode for crate::model::LiquidNetwork {
8009 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8011 <i32>::sse_encode(
8012 match self {
8013 crate::model::LiquidNetwork::Mainnet => 0,
8014 crate::model::LiquidNetwork::Testnet => 1,
8015 crate::model::LiquidNetwork::Regtest => 2,
8016 _ => {
8017 unimplemented!("");
8018 }
8019 },
8020 serializer,
8021 );
8022 }
8023}
8024
8025impl SseEncode for Vec<String> {
8026 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8028 <i32>::sse_encode(self.len() as _, serializer);
8029 for item in self {
8030 <String>::sse_encode(item, serializer);
8031 }
8032 }
8033}
8034
8035impl SseEncode for Vec<crate::model::AssetBalance> {
8036 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8038 <i32>::sse_encode(self.len() as _, serializer);
8039 for item in self {
8040 <crate::model::AssetBalance>::sse_encode(item, serializer);
8041 }
8042 }
8043}
8044
8045impl SseEncode for Vec<crate::model::AssetMetadata> {
8046 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8048 <i32>::sse_encode(self.len() as _, serializer);
8049 for item in self {
8050 <crate::model::AssetMetadata>::sse_encode(item, serializer);
8051 }
8052 }
8053}
8054
8055impl SseEncode for Vec<crate::bindings::ExternalInputParser> {
8056 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8058 <i32>::sse_encode(self.len() as _, serializer);
8059 for item in self {
8060 <crate::bindings::ExternalInputParser>::sse_encode(item, serializer);
8061 }
8062 }
8063}
8064
8065impl SseEncode for Vec<crate::bindings::FiatCurrency> {
8066 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8068 <i32>::sse_encode(self.len() as _, serializer);
8069 for item in self {
8070 <crate::bindings::FiatCurrency>::sse_encode(item, serializer);
8071 }
8072 }
8073}
8074
8075impl SseEncode for Vec<crate::bindings::LnOfferBlindedPath> {
8076 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8078 <i32>::sse_encode(self.len() as _, serializer);
8079 for item in self {
8080 <crate::bindings::LnOfferBlindedPath>::sse_encode(item, serializer);
8081 }
8082 }
8083}
8084
8085impl SseEncode for Vec<crate::bindings::LocaleOverrides> {
8086 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8088 <i32>::sse_encode(self.len() as _, serializer);
8089 for item in self {
8090 <crate::bindings::LocaleOverrides>::sse_encode(item, serializer);
8091 }
8092 }
8093}
8094
8095impl SseEncode for Vec<crate::bindings::LocalizedName> {
8096 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8098 <i32>::sse_encode(self.len() as _, serializer);
8099 for item in self {
8100 <crate::bindings::LocalizedName>::sse_encode(item, serializer);
8101 }
8102 }
8103}
8104
8105impl SseEncode for Vec<crate::model::Payment> {
8106 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8108 <i32>::sse_encode(self.len() as _, serializer);
8109 for item in self {
8110 <crate::model::Payment>::sse_encode(item, serializer);
8111 }
8112 }
8113}
8114
8115impl SseEncode for crate::model::ListPaymentDetails {
8116 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8118 match self {
8119 crate::model::ListPaymentDetails::Liquid {
8120 asset_id,
8121 destination,
8122 } => {
8123 <i32>::sse_encode(0, serializer);
8124 <Option<String>>::sse_encode(asset_id, serializer);
8125 <Option<String>>::sse_encode(destination, serializer);
8126 }
8127 crate::model::ListPaymentDetails::Bitcoin { address } => {
8128 <i32>::sse_encode(1, serializer);
8129 <Option<String>>::sse_encode(address, serializer);
8130 }
8131 _ => {
8132 unimplemented!("");
8133 }
8134 }
8135 }
8136}
8137
8138impl SseEncode for Vec<crate::model::PaymentState> {
8139 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8141 <i32>::sse_encode(self.len() as _, serializer);
8142 for item in self {
8143 <crate::model::PaymentState>::sse_encode(item, serializer);
8144 }
8145 }
8146}
8147
8148impl SseEncode for Vec<crate::model::PaymentType> {
8149 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8151 <i32>::sse_encode(self.len() as _, serializer);
8152 for item in self {
8153 <crate::model::PaymentType>::sse_encode(item, serializer);
8154 }
8155 }
8156}
8157
8158impl SseEncode for crate::model::ListPaymentsRequest {
8159 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8161 <Option<Vec<crate::model::PaymentType>>>::sse_encode(self.filters, serializer);
8162 <Option<Vec<crate::model::PaymentState>>>::sse_encode(self.states, serializer);
8163 <Option<i64>>::sse_encode(self.from_timestamp, serializer);
8164 <Option<i64>>::sse_encode(self.to_timestamp, serializer);
8165 <Option<u32>>::sse_encode(self.offset, serializer);
8166 <Option<u32>>::sse_encode(self.limit, serializer);
8167 <Option<crate::model::ListPaymentDetails>>::sse_encode(self.details, serializer);
8168 <Option<bool>>::sse_encode(self.sort_ascending, serializer);
8169 }
8170}
8171
8172impl SseEncode for Vec<u8> {
8173 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8175 <i32>::sse_encode(self.len() as _, serializer);
8176 for item in self {
8177 <u8>::sse_encode(item, serializer);
8178 }
8179 }
8180}
8181
8182impl SseEncode for Vec<crate::bindings::Rate> {
8183 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8185 <i32>::sse_encode(self.len() as _, serializer);
8186 for item in self {
8187 <crate::bindings::Rate>::sse_encode(item, serializer);
8188 }
8189 }
8190}
8191
8192impl SseEncode for Vec<crate::model::RefundableSwap> {
8193 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8195 <i32>::sse_encode(self.len() as _, serializer);
8196 for item in self {
8197 <crate::model::RefundableSwap>::sse_encode(item, serializer);
8198 }
8199 }
8200}
8201
8202impl SseEncode for Vec<crate::bindings::RouteHint> {
8203 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8205 <i32>::sse_encode(self.len() as _, serializer);
8206 for item in self {
8207 <crate::bindings::RouteHint>::sse_encode(item, serializer);
8208 }
8209 }
8210}
8211
8212impl SseEncode for Vec<crate::bindings::RouteHintHop> {
8213 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8215 <i32>::sse_encode(self.len() as _, serializer);
8216 for item in self {
8217 <crate::bindings::RouteHintHop>::sse_encode(item, serializer);
8218 }
8219 }
8220}
8221
8222impl SseEncode for crate::bindings::LNInvoice {
8223 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8225 <String>::sse_encode(self.bolt11, serializer);
8226 <crate::bindings::Network>::sse_encode(self.network, serializer);
8227 <String>::sse_encode(self.payee_pubkey, serializer);
8228 <String>::sse_encode(self.payment_hash, serializer);
8229 <Option<String>>::sse_encode(self.description, serializer);
8230 <Option<String>>::sse_encode(self.description_hash, serializer);
8231 <Option<u64>>::sse_encode(self.amount_msat, serializer);
8232 <u64>::sse_encode(self.timestamp, serializer);
8233 <u64>::sse_encode(self.expiry, serializer);
8234 <Vec<crate::bindings::RouteHint>>::sse_encode(self.routing_hints, serializer);
8235 <Vec<u8>>::sse_encode(self.payment_secret, serializer);
8236 <u64>::sse_encode(self.min_final_cltv_expiry_delta, serializer);
8237 }
8238}
8239
8240impl SseEncode for crate::bindings::LNOffer {
8241 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8243 <String>::sse_encode(self.offer, serializer);
8244 <Vec<String>>::sse_encode(self.chains, serializer);
8245 <Option<crate::bindings::Amount>>::sse_encode(self.min_amount, serializer);
8246 <Option<String>>::sse_encode(self.description, serializer);
8247 <Option<u64>>::sse_encode(self.absolute_expiry, serializer);
8248 <Option<String>>::sse_encode(self.issuer, serializer);
8249 <Option<String>>::sse_encode(self.signing_pubkey, serializer);
8250 <Vec<crate::bindings::LnOfferBlindedPath>>::sse_encode(self.paths, serializer);
8251 }
8252}
8253
8254impl SseEncode for crate::bindings::LnOfferBlindedPath {
8255 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8257 <Vec<String>>::sse_encode(self.blinded_hops, serializer);
8258 }
8259}
8260
8261impl SseEncode for crate::bindings::duplicates::LnUrlAuthError {
8262 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8264 match self {
8265 crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
8266 <i32>::sse_encode(0, serializer);
8267 <String>::sse_encode(err, serializer);
8268 }
8269 crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
8270 <i32>::sse_encode(1, serializer);
8271 <String>::sse_encode(err, serializer);
8272 }
8273 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
8274 <i32>::sse_encode(2, serializer);
8275 <String>::sse_encode(err, serializer);
8276 }
8277 _ => {
8278 unimplemented!("");
8279 }
8280 }
8281 }
8282}
8283
8284impl SseEncode for crate::bindings::LnUrlAuthRequestData {
8285 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8287 <String>::sse_encode(self.k1, serializer);
8288 <Option<String>>::sse_encode(self.action, serializer);
8289 <String>::sse_encode(self.domain, serializer);
8290 <String>::sse_encode(self.url, serializer);
8291 }
8292}
8293
8294impl SseEncode for crate::bindings::duplicates::LnUrlCallbackStatus {
8295 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8297 match self {
8298 crate::bindings::duplicates::LnUrlCallbackStatus::Ok => {
8299 <i32>::sse_encode(0, serializer);
8300 }
8301 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
8302 <i32>::sse_encode(1, serializer);
8303 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8304 }
8305 _ => {
8306 unimplemented!("");
8307 }
8308 }
8309 }
8310}
8311
8312impl SseEncode for crate::bindings::LnUrlErrorData {
8313 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8315 <String>::sse_encode(self.reason, serializer);
8316 }
8317}
8318
8319impl SseEncode for crate::model::LnUrlInfo {
8320 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8322 <Option<String>>::sse_encode(self.ln_address, serializer);
8323 <Option<String>>::sse_encode(self.lnurl_pay_comment, serializer);
8324 <Option<String>>::sse_encode(self.lnurl_pay_domain, serializer);
8325 <Option<String>>::sse_encode(self.lnurl_pay_metadata, serializer);
8326 <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8327 self.lnurl_pay_success_action,
8328 serializer,
8329 );
8330 <Option<crate::bindings::SuccessAction>>::sse_encode(
8331 self.lnurl_pay_unprocessed_success_action,
8332 serializer,
8333 );
8334 <Option<String>>::sse_encode(self.lnurl_withdraw_endpoint, serializer);
8335 }
8336}
8337
8338impl SseEncode for crate::bindings::duplicates::LnUrlPayError {
8339 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8341 match self {
8342 crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => {
8343 <i32>::sse_encode(0, serializer);
8344 }
8345 crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
8346 <i32>::sse_encode(1, serializer);
8347 <String>::sse_encode(err, serializer);
8348 }
8349 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
8350 <i32>::sse_encode(2, serializer);
8351 <String>::sse_encode(err, serializer);
8352 }
8353 crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
8354 <i32>::sse_encode(3, serializer);
8355 <String>::sse_encode(err, serializer);
8356 }
8357 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
8358 <i32>::sse_encode(4, serializer);
8359 <String>::sse_encode(err, serializer);
8360 }
8361 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
8362 <i32>::sse_encode(5, serializer);
8363 <String>::sse_encode(err, serializer);
8364 }
8365 crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
8366 <i32>::sse_encode(6, serializer);
8367 <String>::sse_encode(err, serializer);
8368 }
8369 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
8370 <i32>::sse_encode(7, serializer);
8371 <String>::sse_encode(err, serializer);
8372 }
8373 crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
8374 <i32>::sse_encode(8, serializer);
8375 <String>::sse_encode(err, serializer);
8376 }
8377 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
8378 <i32>::sse_encode(9, serializer);
8379 <String>::sse_encode(err, serializer);
8380 }
8381 crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
8382 <i32>::sse_encode(10, serializer);
8383 <String>::sse_encode(err, serializer);
8384 }
8385 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
8386 <i32>::sse_encode(11, serializer);
8387 <String>::sse_encode(err, serializer);
8388 }
8389 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
8390 <i32>::sse_encode(12, serializer);
8391 <String>::sse_encode(err, serializer);
8392 }
8393 _ => {
8394 unimplemented!("");
8395 }
8396 }
8397 }
8398}
8399
8400impl SseEncode for crate::bindings::LnUrlPayErrorData {
8401 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8403 <String>::sse_encode(self.payment_hash, serializer);
8404 <String>::sse_encode(self.reason, serializer);
8405 }
8406}
8407
8408impl SseEncode for crate::model::LnUrlPayRequest {
8409 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8411 <crate::model::PrepareLnUrlPayResponse>::sse_encode(self.prepare_response, serializer);
8412 }
8413}
8414
8415impl SseEncode for crate::bindings::LnUrlPayRequestData {
8416 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8418 <String>::sse_encode(self.callback, serializer);
8419 <u64>::sse_encode(self.min_sendable, serializer);
8420 <u64>::sse_encode(self.max_sendable, serializer);
8421 <String>::sse_encode(self.metadata_str, serializer);
8422 <u16>::sse_encode(self.comment_allowed, serializer);
8423 <String>::sse_encode(self.domain, serializer);
8424 <bool>::sse_encode(self.allows_nostr, serializer);
8425 <Option<String>>::sse_encode(self.nostr_pubkey, serializer);
8426 <Option<String>>::sse_encode(self.ln_address, serializer);
8427 }
8428}
8429
8430impl SseEncode for crate::model::LnUrlPayResult {
8431 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8433 match self {
8434 crate::model::LnUrlPayResult::EndpointSuccess { data } => {
8435 <i32>::sse_encode(0, serializer);
8436 <crate::model::LnUrlPaySuccessData>::sse_encode(data, serializer);
8437 }
8438 crate::model::LnUrlPayResult::EndpointError { data } => {
8439 <i32>::sse_encode(1, serializer);
8440 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8441 }
8442 crate::model::LnUrlPayResult::PayError { data } => {
8443 <i32>::sse_encode(2, serializer);
8444 <crate::bindings::LnUrlPayErrorData>::sse_encode(data, serializer);
8445 }
8446 _ => {
8447 unimplemented!("");
8448 }
8449 }
8450 }
8451}
8452
8453impl SseEncode for crate::model::LnUrlPaySuccessData {
8454 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8456 <crate::model::Payment>::sse_encode(self.payment, serializer);
8457 <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8458 self.success_action,
8459 serializer,
8460 );
8461 }
8462}
8463
8464impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawError {
8465 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8467 match self {
8468 crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
8469 <i32>::sse_encode(0, serializer);
8470 <String>::sse_encode(err, serializer);
8471 }
8472 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
8473 <i32>::sse_encode(1, serializer);
8474 <String>::sse_encode(err, serializer);
8475 }
8476 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
8477 <i32>::sse_encode(2, serializer);
8478 <String>::sse_encode(err, serializer);
8479 }
8480 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
8481 <i32>::sse_encode(3, serializer);
8482 <String>::sse_encode(err, serializer);
8483 }
8484 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
8485 <i32>::sse_encode(4, serializer);
8486 <String>::sse_encode(err, serializer);
8487 }
8488 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
8489 <i32>::sse_encode(5, serializer);
8490 <String>::sse_encode(err, serializer);
8491 }
8492 _ => {
8493 unimplemented!("");
8494 }
8495 }
8496 }
8497}
8498
8499impl SseEncode for crate::bindings::LnUrlWithdrawRequest {
8500 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8502 <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(self.data, serializer);
8503 <u64>::sse_encode(self.amount_msat, serializer);
8504 <Option<String>>::sse_encode(self.description, serializer);
8505 }
8506}
8507
8508impl SseEncode for crate::bindings::LnUrlWithdrawRequestData {
8509 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8511 <String>::sse_encode(self.callback, serializer);
8512 <String>::sse_encode(self.k1, serializer);
8513 <String>::sse_encode(self.default_description, serializer);
8514 <u64>::sse_encode(self.min_withdrawable, serializer);
8515 <u64>::sse_encode(self.max_withdrawable, serializer);
8516 }
8517}
8518
8519impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawResult {
8520 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8522 match self {
8523 crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
8524 <i32>::sse_encode(0, serializer);
8525 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8526 data, serializer,
8527 );
8528 }
8529 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
8530 <i32>::sse_encode(1, serializer);
8531 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8532 data, serializer,
8533 );
8534 }
8535 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
8536 <i32>::sse_encode(2, serializer);
8537 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8538 }
8539 _ => {
8540 unimplemented!("");
8541 }
8542 }
8543 }
8544}
8545
8546impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
8547 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8549 <crate::bindings::LNInvoice>::sse_encode(self.invoice, serializer);
8550 }
8551}
8552
8553impl SseEncode for crate::bindings::LocaleOverrides {
8554 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8556 <String>::sse_encode(self.locale, serializer);
8557 <Option<u32>>::sse_encode(self.spacing, serializer);
8558 <crate::bindings::Symbol>::sse_encode(self.symbol, serializer);
8559 }
8560}
8561
8562impl SseEncode for crate::bindings::LocalizedName {
8563 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8565 <String>::sse_encode(self.locale, serializer);
8566 <String>::sse_encode(self.name, serializer);
8567 }
8568}
8569
8570impl SseEncode for crate::model::LogEntry {
8571 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8573 <String>::sse_encode(self.line, serializer);
8574 <String>::sse_encode(self.level, serializer);
8575 }
8576}
8577
8578impl SseEncode for crate::bindings::MessageSuccessActionData {
8579 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8581 <String>::sse_encode(self.message, serializer);
8582 }
8583}
8584
8585impl SseEncode for crate::bindings::Network {
8586 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8588 <i32>::sse_encode(
8589 match self {
8590 crate::bindings::Network::Bitcoin => 0,
8591 crate::bindings::Network::Testnet => 1,
8592 crate::bindings::Network::Signet => 2,
8593 crate::bindings::Network::Regtest => 3,
8594 _ => {
8595 unimplemented!("");
8596 }
8597 },
8598 serializer,
8599 );
8600 }
8601}
8602
8603impl SseEncode for crate::model::OnchainPaymentLimitsResponse {
8604 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8606 <crate::model::Limits>::sse_encode(self.send, serializer);
8607 <crate::model::Limits>::sse_encode(self.receive, serializer);
8608 }
8609}
8610
8611impl SseEncode for Option<String> {
8612 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8614 <bool>::sse_encode(self.is_some(), serializer);
8615 if let Some(value) = self {
8616 <String>::sse_encode(value, serializer);
8617 }
8618 }
8619}
8620
8621impl SseEncode for Option<crate::bindings::Amount> {
8622 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8624 <bool>::sse_encode(self.is_some(), serializer);
8625 if let Some(value) = self {
8626 <crate::bindings::Amount>::sse_encode(value, serializer);
8627 }
8628 }
8629}
8630
8631impl SseEncode for Option<crate::model::AssetInfo> {
8632 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8634 <bool>::sse_encode(self.is_some(), serializer);
8635 if let Some(value) = self {
8636 <crate::model::AssetInfo>::sse_encode(value, serializer);
8637 }
8638 }
8639}
8640
8641impl SseEncode for Option<bool> {
8642 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8644 <bool>::sse_encode(self.is_some(), serializer);
8645 if let Some(value) = self {
8646 <bool>::sse_encode(value, serializer);
8647 }
8648 }
8649}
8650
8651impl SseEncode for Option<f64> {
8652 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8654 <bool>::sse_encode(self.is_some(), serializer);
8655 if let Some(value) = self {
8656 <f64>::sse_encode(value, serializer);
8657 }
8658 }
8659}
8660
8661impl SseEncode for Option<i64> {
8662 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8664 <bool>::sse_encode(self.is_some(), serializer);
8665 if let Some(value) = self {
8666 <i64>::sse_encode(value, serializer);
8667 }
8668 }
8669}
8670
8671impl SseEncode for Option<crate::model::ListPaymentDetails> {
8672 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8674 <bool>::sse_encode(self.is_some(), serializer);
8675 if let Some(value) = self {
8676 <crate::model::ListPaymentDetails>::sse_encode(value, serializer);
8677 }
8678 }
8679}
8680
8681impl SseEncode for Option<crate::model::LnUrlInfo> {
8682 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8684 <bool>::sse_encode(self.is_some(), serializer);
8685 if let Some(value) = self {
8686 <crate::model::LnUrlInfo>::sse_encode(value, serializer);
8687 }
8688 }
8689}
8690
8691impl SseEncode for Option<crate::model::PayAmount> {
8692 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8694 <bool>::sse_encode(self.is_some(), serializer);
8695 if let Some(value) = self {
8696 <crate::model::PayAmount>::sse_encode(value, serializer);
8697 }
8698 }
8699}
8700
8701impl SseEncode for Option<crate::model::Payment> {
8702 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8704 <bool>::sse_encode(self.is_some(), serializer);
8705 if let Some(value) = self {
8706 <crate::model::Payment>::sse_encode(value, serializer);
8707 }
8708 }
8709}
8710
8711impl SseEncode for Option<crate::model::ReceiveAmount> {
8712 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8714 <bool>::sse_encode(self.is_some(), serializer);
8715 if let Some(value) = self {
8716 <crate::model::ReceiveAmount>::sse_encode(value, serializer);
8717 }
8718 }
8719}
8720
8721impl SseEncode for Option<crate::bindings::SuccessAction> {
8722 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8724 <bool>::sse_encode(self.is_some(), serializer);
8725 if let Some(value) = self {
8726 <crate::bindings::SuccessAction>::sse_encode(value, serializer);
8727 }
8728 }
8729}
8730
8731impl SseEncode for Option<crate::bindings::SuccessActionProcessed> {
8732 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8734 <bool>::sse_encode(self.is_some(), serializer);
8735 if let Some(value) = self {
8736 <crate::bindings::SuccessActionProcessed>::sse_encode(value, serializer);
8737 }
8738 }
8739}
8740
8741impl SseEncode for Option<crate::bindings::Symbol> {
8742 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8744 <bool>::sse_encode(self.is_some(), serializer);
8745 if let Some(value) = self {
8746 <crate::bindings::Symbol>::sse_encode(value, serializer);
8747 }
8748 }
8749}
8750
8751impl SseEncode for Option<u32> {
8752 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8754 <bool>::sse_encode(self.is_some(), serializer);
8755 if let Some(value) = self {
8756 <u32>::sse_encode(value, serializer);
8757 }
8758 }
8759}
8760
8761impl SseEncode for Option<u64> {
8762 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8764 <bool>::sse_encode(self.is_some(), serializer);
8765 if let Some(value) = self {
8766 <u64>::sse_encode(value, serializer);
8767 }
8768 }
8769}
8770
8771impl SseEncode for Option<Vec<crate::model::AssetMetadata>> {
8772 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8774 <bool>::sse_encode(self.is_some(), serializer);
8775 if let Some(value) = self {
8776 <Vec<crate::model::AssetMetadata>>::sse_encode(value, serializer);
8777 }
8778 }
8779}
8780
8781impl SseEncode for Option<Vec<crate::bindings::ExternalInputParser>> {
8782 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8784 <bool>::sse_encode(self.is_some(), serializer);
8785 if let Some(value) = self {
8786 <Vec<crate::bindings::ExternalInputParser>>::sse_encode(value, serializer);
8787 }
8788 }
8789}
8790
8791impl SseEncode for Option<Vec<crate::model::PaymentState>> {
8792 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8794 <bool>::sse_encode(self.is_some(), serializer);
8795 if let Some(value) = self {
8796 <Vec<crate::model::PaymentState>>::sse_encode(value, serializer);
8797 }
8798 }
8799}
8800
8801impl SseEncode for Option<Vec<crate::model::PaymentType>> {
8802 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8804 <bool>::sse_encode(self.is_some(), serializer);
8805 if let Some(value) = self {
8806 <Vec<crate::model::PaymentType>>::sse_encode(value, serializer);
8807 }
8808 }
8809}
8810
8811impl SseEncode for Option<Vec<u8>> {
8812 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8814 <bool>::sse_encode(self.is_some(), serializer);
8815 if let Some(value) = self {
8816 <Vec<u8>>::sse_encode(value, serializer);
8817 }
8818 }
8819}
8820
8821impl SseEncode for crate::model::PayAmount {
8822 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8824 match self {
8825 crate::model::PayAmount::Bitcoin {
8826 receiver_amount_sat,
8827 } => {
8828 <i32>::sse_encode(0, serializer);
8829 <u64>::sse_encode(receiver_amount_sat, serializer);
8830 }
8831 crate::model::PayAmount::Asset {
8832 to_asset,
8833 receiver_amount,
8834 estimate_asset_fees,
8835 from_asset,
8836 } => {
8837 <i32>::sse_encode(1, serializer);
8838 <String>::sse_encode(to_asset, serializer);
8839 <f64>::sse_encode(receiver_amount, serializer);
8840 <Option<bool>>::sse_encode(estimate_asset_fees, serializer);
8841 <Option<String>>::sse_encode(from_asset, serializer);
8842 }
8843 crate::model::PayAmount::Drain => {
8844 <i32>::sse_encode(2, serializer);
8845 }
8846 _ => {
8847 unimplemented!("");
8848 }
8849 }
8850 }
8851}
8852
8853impl SseEncode for crate::model::PayOnchainRequest {
8854 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8856 <String>::sse_encode(self.address, serializer);
8857 <crate::model::PreparePayOnchainResponse>::sse_encode(self.prepare_response, serializer);
8858 }
8859}
8860
8861impl SseEncode for crate::model::Payment {
8862 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8864 <Option<String>>::sse_encode(self.destination, serializer);
8865 <Option<String>>::sse_encode(self.tx_id, serializer);
8866 <Option<String>>::sse_encode(self.unblinding_data, serializer);
8867 <u32>::sse_encode(self.timestamp, serializer);
8868 <u64>::sse_encode(self.amount_sat, serializer);
8869 <u64>::sse_encode(self.fees_sat, serializer);
8870 <Option<u64>>::sse_encode(self.swapper_fees_sat, serializer);
8871 <crate::model::PaymentType>::sse_encode(self.payment_type, serializer);
8872 <crate::model::PaymentState>::sse_encode(self.status, serializer);
8873 <crate::model::PaymentDetails>::sse_encode(self.details, serializer);
8874 }
8875}
8876
8877impl SseEncode for crate::model::PaymentDetails {
8878 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8880 match self {
8881 crate::model::PaymentDetails::Lightning {
8882 swap_id,
8883 description,
8884 liquid_expiration_blockheight,
8885 preimage,
8886 invoice,
8887 bolt12_offer,
8888 payment_hash,
8889 destination_pubkey,
8890 lnurl_info,
8891 bip353_address,
8892 payer_note,
8893 claim_tx_id,
8894 refund_tx_id,
8895 refund_tx_amount_sat,
8896 } => {
8897 <i32>::sse_encode(0, serializer);
8898 <String>::sse_encode(swap_id, serializer);
8899 <String>::sse_encode(description, serializer);
8900 <u32>::sse_encode(liquid_expiration_blockheight, serializer);
8901 <Option<String>>::sse_encode(preimage, serializer);
8902 <Option<String>>::sse_encode(invoice, serializer);
8903 <Option<String>>::sse_encode(bolt12_offer, serializer);
8904 <Option<String>>::sse_encode(payment_hash, serializer);
8905 <Option<String>>::sse_encode(destination_pubkey, serializer);
8906 <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8907 <Option<String>>::sse_encode(bip353_address, serializer);
8908 <Option<String>>::sse_encode(payer_note, serializer);
8909 <Option<String>>::sse_encode(claim_tx_id, serializer);
8910 <Option<String>>::sse_encode(refund_tx_id, serializer);
8911 <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8912 }
8913 crate::model::PaymentDetails::Liquid {
8914 destination,
8915 description,
8916 asset_id,
8917 asset_info,
8918 lnurl_info,
8919 bip353_address,
8920 payer_note,
8921 } => {
8922 <i32>::sse_encode(1, serializer);
8923 <String>::sse_encode(destination, serializer);
8924 <String>::sse_encode(description, serializer);
8925 <String>::sse_encode(asset_id, serializer);
8926 <Option<crate::model::AssetInfo>>::sse_encode(asset_info, serializer);
8927 <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8928 <Option<String>>::sse_encode(bip353_address, serializer);
8929 <Option<String>>::sse_encode(payer_note, serializer);
8930 }
8931 crate::model::PaymentDetails::Bitcoin {
8932 swap_id,
8933 bitcoin_address,
8934 description,
8935 auto_accepted_fees,
8936 liquid_expiration_blockheight,
8937 bitcoin_expiration_blockheight,
8938 lockup_tx_id,
8939 claim_tx_id,
8940 refund_tx_id,
8941 refund_tx_amount_sat,
8942 } => {
8943 <i32>::sse_encode(2, serializer);
8944 <String>::sse_encode(swap_id, serializer);
8945 <String>::sse_encode(bitcoin_address, serializer);
8946 <String>::sse_encode(description, serializer);
8947 <bool>::sse_encode(auto_accepted_fees, serializer);
8948 <u32>::sse_encode(liquid_expiration_blockheight, serializer);
8949 <u32>::sse_encode(bitcoin_expiration_blockheight, serializer);
8950 <Option<String>>::sse_encode(lockup_tx_id, serializer);
8951 <Option<String>>::sse_encode(claim_tx_id, serializer);
8952 <Option<String>>::sse_encode(refund_tx_id, serializer);
8953 <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8954 }
8955 _ => {
8956 unimplemented!("");
8957 }
8958 }
8959 }
8960}
8961
8962impl SseEncode for crate::error::PaymentError {
8963 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8965 match self {
8966 crate::error::PaymentError::AlreadyClaimed => {
8967 <i32>::sse_encode(0, serializer);
8968 }
8969 crate::error::PaymentError::AlreadyPaid => {
8970 <i32>::sse_encode(1, serializer);
8971 }
8972 crate::error::PaymentError::PaymentInProgress => {
8973 <i32>::sse_encode(2, serializer);
8974 }
8975 crate::error::PaymentError::AmountOutOfRange { min, max } => {
8976 <i32>::sse_encode(3, serializer);
8977 <u64>::sse_encode(min, serializer);
8978 <u64>::sse_encode(max, serializer);
8979 }
8980 crate::error::PaymentError::AmountMissing { err } => {
8981 <i32>::sse_encode(4, serializer);
8982 <String>::sse_encode(err, serializer);
8983 }
8984 crate::error::PaymentError::AssetError { err } => {
8985 <i32>::sse_encode(5, serializer);
8986 <String>::sse_encode(err, serializer);
8987 }
8988 crate::error::PaymentError::InvalidNetwork { err } => {
8989 <i32>::sse_encode(6, serializer);
8990 <String>::sse_encode(err, serializer);
8991 }
8992 crate::error::PaymentError::Generic { err } => {
8993 <i32>::sse_encode(7, serializer);
8994 <String>::sse_encode(err, serializer);
8995 }
8996 crate::error::PaymentError::InvalidOrExpiredFees => {
8997 <i32>::sse_encode(8, serializer);
8998 }
8999 crate::error::PaymentError::InsufficientFunds => {
9000 <i32>::sse_encode(9, serializer);
9001 }
9002 crate::error::PaymentError::InvalidDescription { err } => {
9003 <i32>::sse_encode(10, serializer);
9004 <String>::sse_encode(err, serializer);
9005 }
9006 crate::error::PaymentError::InvalidInvoice { err } => {
9007 <i32>::sse_encode(11, serializer);
9008 <String>::sse_encode(err, serializer);
9009 }
9010 crate::error::PaymentError::InvalidPreimage => {
9011 <i32>::sse_encode(12, serializer);
9012 }
9013 crate::error::PaymentError::PairsNotFound => {
9014 <i32>::sse_encode(13, serializer);
9015 }
9016 crate::error::PaymentError::PaymentTimeout => {
9017 <i32>::sse_encode(14, serializer);
9018 }
9019 crate::error::PaymentError::PersistError => {
9020 <i32>::sse_encode(15, serializer);
9021 }
9022 crate::error::PaymentError::ReceiveError { err } => {
9023 <i32>::sse_encode(16, serializer);
9024 <String>::sse_encode(err, serializer);
9025 }
9026 crate::error::PaymentError::Refunded { err, refund_tx_id } => {
9027 <i32>::sse_encode(17, serializer);
9028 <String>::sse_encode(err, serializer);
9029 <String>::sse_encode(refund_tx_id, serializer);
9030 }
9031 crate::error::PaymentError::SelfTransferNotSupported => {
9032 <i32>::sse_encode(18, serializer);
9033 }
9034 crate::error::PaymentError::SendError { err } => {
9035 <i32>::sse_encode(19, serializer);
9036 <String>::sse_encode(err, serializer);
9037 }
9038 crate::error::PaymentError::SignerError { err } => {
9039 <i32>::sse_encode(20, serializer);
9040 <String>::sse_encode(err, serializer);
9041 }
9042 _ => {
9043 unimplemented!("");
9044 }
9045 }
9046 }
9047}
9048
9049impl SseEncode for crate::model::PaymentMethod {
9050 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9052 <i32>::sse_encode(
9053 match self {
9054 crate::model::PaymentMethod::Lightning => 0,
9055 crate::model::PaymentMethod::Bolt11Invoice => 1,
9056 crate::model::PaymentMethod::Bolt12Offer => 2,
9057 crate::model::PaymentMethod::BitcoinAddress => 3,
9058 crate::model::PaymentMethod::LiquidAddress => 4,
9059 _ => {
9060 unimplemented!("");
9061 }
9062 },
9063 serializer,
9064 );
9065 }
9066}
9067
9068impl SseEncode for crate::model::PaymentState {
9069 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9071 <i32>::sse_encode(
9072 match self {
9073 crate::model::PaymentState::Created => 0,
9074 crate::model::PaymentState::Pending => 1,
9075 crate::model::PaymentState::Complete => 2,
9076 crate::model::PaymentState::Failed => 3,
9077 crate::model::PaymentState::TimedOut => 4,
9078 crate::model::PaymentState::Refundable => 5,
9079 crate::model::PaymentState::RefundPending => 6,
9080 crate::model::PaymentState::WaitingFeeAcceptance => 7,
9081 _ => {
9082 unimplemented!("");
9083 }
9084 },
9085 serializer,
9086 );
9087 }
9088}
9089
9090impl SseEncode for crate::model::PaymentType {
9091 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9093 <i32>::sse_encode(
9094 match self {
9095 crate::model::PaymentType::Receive => 0,
9096 crate::model::PaymentType::Send => 1,
9097 _ => {
9098 unimplemented!("");
9099 }
9100 },
9101 serializer,
9102 );
9103 }
9104}
9105
9106impl SseEncode for crate::model::PrepareBuyBitcoinRequest {
9107 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9109 <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9110 <u64>::sse_encode(self.amount_sat, serializer);
9111 }
9112}
9113
9114impl SseEncode for crate::model::PrepareBuyBitcoinResponse {
9115 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9117 <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9118 <u64>::sse_encode(self.amount_sat, serializer);
9119 <u64>::sse_encode(self.fees_sat, serializer);
9120 }
9121}
9122
9123impl SseEncode for crate::model::PrepareLnUrlPayRequest {
9124 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9126 <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9127 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9128 <Option<String>>::sse_encode(self.bip353_address, serializer);
9129 <Option<String>>::sse_encode(self.comment, serializer);
9130 <Option<bool>>::sse_encode(self.validate_success_action_url, serializer);
9131 }
9132}
9133
9134impl SseEncode for crate::model::PrepareLnUrlPayResponse {
9135 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9137 <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9138 <u64>::sse_encode(self.fees_sat, serializer);
9139 <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9140 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9141 <Option<String>>::sse_encode(self.comment, serializer);
9142 <Option<crate::bindings::SuccessAction>>::sse_encode(self.success_action, serializer);
9143 }
9144}
9145
9146impl SseEncode for crate::model::PreparePayOnchainRequest {
9147 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9149 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9150 <Option<u32>>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9151 }
9152}
9153
9154impl SseEncode for crate::model::PreparePayOnchainResponse {
9155 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9157 <u64>::sse_encode(self.receiver_amount_sat, serializer);
9158 <u64>::sse_encode(self.claim_fees_sat, serializer);
9159 <u64>::sse_encode(self.total_fees_sat, serializer);
9160 }
9161}
9162
9163impl SseEncode for crate::model::PrepareReceiveRequest {
9164 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9166 <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9167 <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9168 }
9169}
9170
9171impl SseEncode for crate::model::PrepareReceiveResponse {
9172 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9174 <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9175 <u64>::sse_encode(self.fees_sat, serializer);
9176 <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9177 <Option<u64>>::sse_encode(self.min_payer_amount_sat, serializer);
9178 <Option<u64>>::sse_encode(self.max_payer_amount_sat, serializer);
9179 <Option<f64>>::sse_encode(self.swapper_feerate, serializer);
9180 }
9181}
9182
9183impl SseEncode for crate::model::PrepareRefundRequest {
9184 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9186 <String>::sse_encode(self.swap_address, serializer);
9187 <String>::sse_encode(self.refund_address, serializer);
9188 <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9189 }
9190}
9191
9192impl SseEncode for crate::model::PrepareRefundResponse {
9193 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9195 <u32>::sse_encode(self.tx_vsize, serializer);
9196 <u64>::sse_encode(self.tx_fee_sat, serializer);
9197 <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9198 }
9199}
9200
9201impl SseEncode for crate::model::PrepareSendRequest {
9202 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9204 <String>::sse_encode(self.destination, serializer);
9205 <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9206 }
9207}
9208
9209impl SseEncode for crate::model::PrepareSendResponse {
9210 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9212 <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9213 <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9214 <Option<u64>>::sse_encode(self.fees_sat, serializer);
9215 <Option<f64>>::sse_encode(self.estimated_asset_fees, serializer);
9216 <Option<u64>>::sse_encode(self.exchange_amount_sat, serializer);
9217 }
9218}
9219
9220impl SseEncode for crate::bindings::Rate {
9221 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9223 <String>::sse_encode(self.coin, serializer);
9224 <f64>::sse_encode(self.value, serializer);
9225 }
9226}
9227
9228impl SseEncode for crate::model::ReceiveAmount {
9229 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9231 match self {
9232 crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
9233 <i32>::sse_encode(0, serializer);
9234 <u64>::sse_encode(payer_amount_sat, serializer);
9235 }
9236 crate::model::ReceiveAmount::Asset {
9237 asset_id,
9238 payer_amount,
9239 } => {
9240 <i32>::sse_encode(1, serializer);
9241 <String>::sse_encode(asset_id, serializer);
9242 <Option<f64>>::sse_encode(payer_amount, serializer);
9243 }
9244 _ => {
9245 unimplemented!("");
9246 }
9247 }
9248 }
9249}
9250
9251impl SseEncode for crate::model::ReceivePaymentRequest {
9252 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9254 <crate::model::PrepareReceiveResponse>::sse_encode(self.prepare_response, serializer);
9255 <Option<String>>::sse_encode(self.description, serializer);
9256 <Option<bool>>::sse_encode(self.use_description_hash, serializer);
9257 <Option<String>>::sse_encode(self.payer_note, serializer);
9258 }
9259}
9260
9261impl SseEncode for crate::model::ReceivePaymentResponse {
9262 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9264 <String>::sse_encode(self.destination, serializer);
9265 <Option<u32>>::sse_encode(self.liquid_expiration_blockheight, serializer);
9266 <Option<u32>>::sse_encode(self.bitcoin_expiration_blockheight, serializer);
9267 }
9268}
9269
9270impl SseEncode for crate::model::RecommendedFees {
9271 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9273 <u64>::sse_encode(self.fastest_fee, serializer);
9274 <u64>::sse_encode(self.half_hour_fee, serializer);
9275 <u64>::sse_encode(self.hour_fee, serializer);
9276 <u64>::sse_encode(self.economy_fee, serializer);
9277 <u64>::sse_encode(self.minimum_fee, serializer);
9278 }
9279}
9280
9281impl SseEncode for crate::model::RefundRequest {
9282 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9284 <String>::sse_encode(self.swap_address, serializer);
9285 <String>::sse_encode(self.refund_address, serializer);
9286 <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9287 }
9288}
9289
9290impl SseEncode for crate::model::RefundResponse {
9291 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9293 <String>::sse_encode(self.refund_tx_id, serializer);
9294 }
9295}
9296
9297impl SseEncode for crate::model::RefundableSwap {
9298 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9300 <String>::sse_encode(self.swap_address, serializer);
9301 <u32>::sse_encode(self.timestamp, serializer);
9302 <u64>::sse_encode(self.amount_sat, serializer);
9303 <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9304 }
9305}
9306
9307impl SseEncode for crate::model::RestoreRequest {
9308 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9310 <Option<String>>::sse_encode(self.backup_path, serializer);
9311 }
9312}
9313
9314impl SseEncode for crate::bindings::RouteHint {
9315 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9317 <Vec<crate::bindings::RouteHintHop>>::sse_encode(self.hops, serializer);
9318 }
9319}
9320
9321impl SseEncode for crate::bindings::RouteHintHop {
9322 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9324 <String>::sse_encode(self.src_node_id, serializer);
9325 <String>::sse_encode(self.short_channel_id, serializer);
9326 <u32>::sse_encode(self.fees_base_msat, serializer);
9327 <u32>::sse_encode(self.fees_proportional_millionths, serializer);
9328 <u64>::sse_encode(self.cltv_expiry_delta, serializer);
9329 <Option<u64>>::sse_encode(self.htlc_minimum_msat, serializer);
9330 <Option<u64>>::sse_encode(self.htlc_maximum_msat, serializer);
9331 }
9332}
9333
9334impl SseEncode for crate::error::SdkError {
9335 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9337 match self {
9338 crate::error::SdkError::AlreadyStarted => {
9339 <i32>::sse_encode(0, serializer);
9340 }
9341 crate::error::SdkError::Generic { err } => {
9342 <i32>::sse_encode(1, serializer);
9343 <String>::sse_encode(err, serializer);
9344 }
9345 crate::error::SdkError::NotStarted => {
9346 <i32>::sse_encode(2, serializer);
9347 }
9348 crate::error::SdkError::ServiceConnectivity { err } => {
9349 <i32>::sse_encode(3, serializer);
9350 <String>::sse_encode(err, serializer);
9351 }
9352 _ => {
9353 unimplemented!("");
9354 }
9355 }
9356 }
9357}
9358
9359impl SseEncode for crate::model::SdkEvent {
9360 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9362 match self {
9363 crate::model::SdkEvent::PaymentFailed { details } => {
9364 <i32>::sse_encode(0, serializer);
9365 <crate::model::Payment>::sse_encode(details, serializer);
9366 }
9367 crate::model::SdkEvent::PaymentPending { details } => {
9368 <i32>::sse_encode(1, serializer);
9369 <crate::model::Payment>::sse_encode(details, serializer);
9370 }
9371 crate::model::SdkEvent::PaymentRefundable { details } => {
9372 <i32>::sse_encode(2, serializer);
9373 <crate::model::Payment>::sse_encode(details, serializer);
9374 }
9375 crate::model::SdkEvent::PaymentRefunded { details } => {
9376 <i32>::sse_encode(3, serializer);
9377 <crate::model::Payment>::sse_encode(details, serializer);
9378 }
9379 crate::model::SdkEvent::PaymentRefundPending { details } => {
9380 <i32>::sse_encode(4, serializer);
9381 <crate::model::Payment>::sse_encode(details, serializer);
9382 }
9383 crate::model::SdkEvent::PaymentSucceeded { details } => {
9384 <i32>::sse_encode(5, serializer);
9385 <crate::model::Payment>::sse_encode(details, serializer);
9386 }
9387 crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
9388 <i32>::sse_encode(6, serializer);
9389 <crate::model::Payment>::sse_encode(details, serializer);
9390 }
9391 crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
9392 <i32>::sse_encode(7, serializer);
9393 <crate::model::Payment>::sse_encode(details, serializer);
9394 }
9395 crate::model::SdkEvent::Synced => {
9396 <i32>::sse_encode(8, serializer);
9397 }
9398 crate::model::SdkEvent::DataSynced {
9399 did_pull_new_records,
9400 } => {
9401 <i32>::sse_encode(9, serializer);
9402 <bool>::sse_encode(did_pull_new_records, serializer);
9403 }
9404 _ => {
9405 unimplemented!("");
9406 }
9407 }
9408 }
9409}
9410
9411impl SseEncode for crate::model::SendDestination {
9412 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9414 match self {
9415 crate::model::SendDestination::LiquidAddress {
9416 address_data,
9417 bip353_address,
9418 } => {
9419 <i32>::sse_encode(0, serializer);
9420 <crate::bindings::LiquidAddressData>::sse_encode(address_data, serializer);
9421 <Option<String>>::sse_encode(bip353_address, serializer);
9422 }
9423 crate::model::SendDestination::Bolt11 {
9424 invoice,
9425 bip353_address,
9426 } => {
9427 <i32>::sse_encode(1, serializer);
9428 <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
9429 <Option<String>>::sse_encode(bip353_address, serializer);
9430 }
9431 crate::model::SendDestination::Bolt12 {
9432 offer,
9433 receiver_amount_sat,
9434 bip353_address,
9435 } => {
9436 <i32>::sse_encode(2, serializer);
9437 <crate::bindings::LNOffer>::sse_encode(offer, serializer);
9438 <u64>::sse_encode(receiver_amount_sat, serializer);
9439 <Option<String>>::sse_encode(bip353_address, serializer);
9440 }
9441 _ => {
9442 unimplemented!("");
9443 }
9444 }
9445 }
9446}
9447
9448impl SseEncode for crate::model::SendPaymentRequest {
9449 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9451 <crate::model::PrepareSendResponse>::sse_encode(self.prepare_response, serializer);
9452 <Option<bool>>::sse_encode(self.use_asset_fees, serializer);
9453 <Option<String>>::sse_encode(self.payer_note, serializer);
9454 }
9455}
9456
9457impl SseEncode for crate::model::SendPaymentResponse {
9458 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9460 <crate::model::Payment>::sse_encode(self.payment, serializer);
9461 }
9462}
9463
9464impl SseEncode for crate::model::SignMessageRequest {
9465 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9467 <String>::sse_encode(self.message, serializer);
9468 }
9469}
9470
9471impl SseEncode for crate::model::SignMessageResponse {
9472 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9474 <String>::sse_encode(self.signature, serializer);
9475 }
9476}
9477
9478impl SseEncode for crate::bindings::SuccessAction {
9479 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9481 match self {
9482 crate::bindings::SuccessAction::Aes { data } => {
9483 <i32>::sse_encode(0, serializer);
9484 <crate::bindings::AesSuccessActionData>::sse_encode(data, serializer);
9485 }
9486 crate::bindings::SuccessAction::Message { data } => {
9487 <i32>::sse_encode(1, serializer);
9488 <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9489 }
9490 crate::bindings::SuccessAction::Url { data } => {
9491 <i32>::sse_encode(2, serializer);
9492 <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9493 }
9494 _ => {
9495 unimplemented!("");
9496 }
9497 }
9498 }
9499}
9500
9501impl SseEncode for crate::bindings::SuccessActionProcessed {
9502 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9504 match self {
9505 crate::bindings::SuccessActionProcessed::Aes { result } => {
9506 <i32>::sse_encode(0, serializer);
9507 <crate::bindings::AesSuccessActionDataResult>::sse_encode(result, serializer);
9508 }
9509 crate::bindings::SuccessActionProcessed::Message { data } => {
9510 <i32>::sse_encode(1, serializer);
9511 <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9512 }
9513 crate::bindings::SuccessActionProcessed::Url { data } => {
9514 <i32>::sse_encode(2, serializer);
9515 <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9516 }
9517 _ => {
9518 unimplemented!("");
9519 }
9520 }
9521 }
9522}
9523
9524impl SseEncode for crate::bindings::Symbol {
9525 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9527 <Option<String>>::sse_encode(self.grapheme, serializer);
9528 <Option<String>>::sse_encode(self.template, serializer);
9529 <Option<bool>>::sse_encode(self.rtl, serializer);
9530 <Option<u32>>::sse_encode(self.position, serializer);
9531 }
9532}
9533
9534impl SseEncode for u16 {
9535 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9537 serializer.cursor.write_u16::<NativeEndian>(self).unwrap();
9538 }
9539}
9540
9541impl SseEncode for u32 {
9542 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9544 serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
9545 }
9546}
9547
9548impl SseEncode for u64 {
9549 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9551 serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
9552 }
9553}
9554
9555impl SseEncode for u8 {
9556 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9558 serializer.cursor.write_u8(self).unwrap();
9559 }
9560}
9561
9562impl SseEncode for () {
9563 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
9565}
9566
9567impl SseEncode for crate::bindings::UrlSuccessActionData {
9568 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9570 <String>::sse_encode(self.description, serializer);
9571 <String>::sse_encode(self.url, serializer);
9572 <bool>::sse_encode(self.matches_callback_domain, serializer);
9573 }
9574}
9575
9576impl SseEncode for usize {
9577 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9579 serializer
9580 .cursor
9581 .write_u64::<NativeEndian>(self as _)
9582 .unwrap();
9583 }
9584}
9585
9586impl SseEncode for crate::model::WalletInfo {
9587 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9589 <u64>::sse_encode(self.balance_sat, serializer);
9590 <u64>::sse_encode(self.pending_send_sat, serializer);
9591 <u64>::sse_encode(self.pending_receive_sat, serializer);
9592 <String>::sse_encode(self.fingerprint, serializer);
9593 <String>::sse_encode(self.pubkey, serializer);
9594 <Vec<crate::model::AssetBalance>>::sse_encode(self.asset_balances, serializer);
9595 }
9596}
9597
9598#[cfg(not(target_family = "wasm"))]
9599mod io {
9600 use super::*;
9606 use crate::bindings::*;
9607 use crate::model::EventListener;
9608 use flutter_rust_bridge::for_generated::byteorder::{
9609 NativeEndian, ReadBytesExt, WriteBytesExt,
9610 };
9611 use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
9612 use flutter_rust_bridge::{Handler, IntoIntoDart};
9613
9614 flutter_rust_bridge::frb_generated_boilerplate_io!();
9617
9618 impl CstDecode<flutter_rust_bridge::for_generated::anyhow::Error>
9621 for *mut wire_cst_list_prim_u_8_strict
9622 {
9623 fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error {
9625 unimplemented!()
9626 }
9627 }
9628 impl CstDecode<BindingLiquidSdk> for usize {
9629 fn cst_decode(self) -> BindingLiquidSdk {
9631 flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::<
9632 RustOpaqueNom<
9633 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9634 >,
9635 >::cst_decode(
9636 self
9637 ))
9638 }
9639 }
9640 impl
9641 CstDecode<
9642 RustOpaqueNom<
9643 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9644 >,
9645 > for usize
9646 {
9647 fn cst_decode(
9649 self,
9650 ) -> RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
9651 {
9652 unsafe { decode_rust_opaque_nom(self as _) }
9653 }
9654 }
9655 impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>
9656 for *mut wire_cst_list_prim_u_8_strict
9657 {
9658 fn cst_decode(
9660 self,
9661 ) -> StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
9662 {
9663 let raw: String = self.cst_decode();
9664 StreamSink::deserialize(raw)
9665 }
9666 }
9667 impl CstDecode<StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>>
9668 for *mut wire_cst_list_prim_u_8_strict
9669 {
9670 fn cst_decode(
9672 self,
9673 ) -> StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
9674 {
9675 let raw: String = self.cst_decode();
9676 StreamSink::deserialize(raw)
9677 }
9678 }
9679 impl CstDecode<String> for *mut wire_cst_list_prim_u_8_strict {
9680 fn cst_decode(self) -> String {
9682 let vec: Vec<u8> = self.cst_decode();
9683 String::from_utf8(vec).unwrap()
9684 }
9685 }
9686 impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9687 for wire_cst_accept_payment_proposed_fees_request
9688 {
9689 fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9691 crate::model::AcceptPaymentProposedFeesRequest {
9692 response: self.response.cst_decode(),
9693 }
9694 }
9695 }
9696 impl CstDecode<crate::bindings::AesSuccessActionData> for wire_cst_aes_success_action_data {
9697 fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9699 crate::bindings::AesSuccessActionData {
9700 description: self.description.cst_decode(),
9701 ciphertext: self.ciphertext.cst_decode(),
9702 iv: self.iv.cst_decode(),
9703 }
9704 }
9705 }
9706 impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9707 for wire_cst_aes_success_action_data_decrypted
9708 {
9709 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9711 crate::bindings::AesSuccessActionDataDecrypted {
9712 description: self.description.cst_decode(),
9713 plaintext: self.plaintext.cst_decode(),
9714 }
9715 }
9716 }
9717 impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9718 for wire_cst_aes_success_action_data_result
9719 {
9720 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9722 match self.tag {
9723 0 => {
9724 let ans = unsafe { self.kind.Decrypted };
9725 crate::bindings::AesSuccessActionDataResult::Decrypted {
9726 data: ans.data.cst_decode(),
9727 }
9728 }
9729 1 => {
9730 let ans = unsafe { self.kind.ErrorStatus };
9731 crate::bindings::AesSuccessActionDataResult::ErrorStatus {
9732 reason: ans.reason.cst_decode(),
9733 }
9734 }
9735 _ => unreachable!(),
9736 }
9737 }
9738 }
9739 impl CstDecode<crate::bindings::Amount> for wire_cst_amount {
9740 fn cst_decode(self) -> crate::bindings::Amount {
9742 match self.tag {
9743 0 => {
9744 let ans = unsafe { self.kind.Bitcoin };
9745 crate::bindings::Amount::Bitcoin {
9746 amount_msat: ans.amount_msat.cst_decode(),
9747 }
9748 }
9749 1 => {
9750 let ans = unsafe { self.kind.Currency };
9751 crate::bindings::Amount::Currency {
9752 iso4217_code: ans.iso4217_code.cst_decode(),
9753 fractional_amount: ans.fractional_amount.cst_decode(),
9754 }
9755 }
9756 _ => unreachable!(),
9757 }
9758 }
9759 }
9760 impl CstDecode<crate::model::AssetBalance> for wire_cst_asset_balance {
9761 fn cst_decode(self) -> crate::model::AssetBalance {
9763 crate::model::AssetBalance {
9764 asset_id: self.asset_id.cst_decode(),
9765 balance_sat: self.balance_sat.cst_decode(),
9766 name: self.name.cst_decode(),
9767 ticker: self.ticker.cst_decode(),
9768 balance: self.balance.cst_decode(),
9769 }
9770 }
9771 }
9772 impl CstDecode<crate::model::AssetInfo> for wire_cst_asset_info {
9773 fn cst_decode(self) -> crate::model::AssetInfo {
9775 crate::model::AssetInfo {
9776 name: self.name.cst_decode(),
9777 ticker: self.ticker.cst_decode(),
9778 amount: self.amount.cst_decode(),
9779 fees: self.fees.cst_decode(),
9780 }
9781 }
9782 }
9783 impl CstDecode<crate::model::AssetMetadata> for wire_cst_asset_metadata {
9784 fn cst_decode(self) -> crate::model::AssetMetadata {
9786 crate::model::AssetMetadata {
9787 asset_id: self.asset_id.cst_decode(),
9788 name: self.name.cst_decode(),
9789 ticker: self.ticker.cst_decode(),
9790 precision: self.precision.cst_decode(),
9791 fiat_id: self.fiat_id.cst_decode(),
9792 }
9793 }
9794 }
9795 impl CstDecode<crate::model::BackupRequest> for wire_cst_backup_request {
9796 fn cst_decode(self) -> crate::model::BackupRequest {
9798 crate::model::BackupRequest {
9799 backup_path: self.backup_path.cst_decode(),
9800 }
9801 }
9802 }
9803 impl CstDecode<crate::bindings::BindingEventListener> for wire_cst_binding_event_listener {
9804 fn cst_decode(self) -> crate::bindings::BindingEventListener {
9806 crate::bindings::BindingEventListener {
9807 stream: self.stream.cst_decode(),
9808 }
9809 }
9810 }
9811 impl CstDecode<crate::bindings::BitcoinAddressData> for wire_cst_bitcoin_address_data {
9812 fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9814 crate::bindings::BitcoinAddressData {
9815 address: self.address.cst_decode(),
9816 network: self.network.cst_decode(),
9817 amount_sat: self.amount_sat.cst_decode(),
9818 label: self.label.cst_decode(),
9819 message: self.message.cst_decode(),
9820 }
9821 }
9822 }
9823 impl CstDecode<crate::model::BlockchainExplorer> for wire_cst_blockchain_explorer {
9824 fn cst_decode(self) -> crate::model::BlockchainExplorer {
9826 match self.tag {
9827 0 => {
9828 let ans = unsafe { self.kind.Electrum };
9829 crate::model::BlockchainExplorer::Electrum {
9830 url: ans.url.cst_decode(),
9831 }
9832 }
9833 1 => {
9834 let ans = unsafe { self.kind.Esplora };
9835 crate::model::BlockchainExplorer::Esplora {
9836 url: ans.url.cst_decode(),
9837 use_waterfalls: ans.use_waterfalls.cst_decode(),
9838 }
9839 }
9840 _ => unreachable!(),
9841 }
9842 }
9843 }
9844 impl CstDecode<crate::model::BlockchainInfo> for wire_cst_blockchain_info {
9845 fn cst_decode(self) -> crate::model::BlockchainInfo {
9847 crate::model::BlockchainInfo {
9848 liquid_tip: self.liquid_tip.cst_decode(),
9849 bitcoin_tip: self.bitcoin_tip.cst_decode(),
9850 }
9851 }
9852 }
9853 impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9854 for *mut wire_cst_accept_payment_proposed_fees_request
9855 {
9856 fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9858 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9859 CstDecode::<crate::model::AcceptPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9860 }
9861 }
9862 impl CstDecode<crate::bindings::AesSuccessActionData> for *mut wire_cst_aes_success_action_data {
9863 fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9865 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9866 CstDecode::<crate::bindings::AesSuccessActionData>::cst_decode(*wrap).into()
9867 }
9868 }
9869 impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9870 for *mut wire_cst_aes_success_action_data_decrypted
9871 {
9872 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9874 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9875 CstDecode::<crate::bindings::AesSuccessActionDataDecrypted>::cst_decode(*wrap).into()
9876 }
9877 }
9878 impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9879 for *mut wire_cst_aes_success_action_data_result
9880 {
9881 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9883 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9884 CstDecode::<crate::bindings::AesSuccessActionDataResult>::cst_decode(*wrap).into()
9885 }
9886 }
9887 impl CstDecode<crate::bindings::Amount> for *mut wire_cst_amount {
9888 fn cst_decode(self) -> crate::bindings::Amount {
9890 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9891 CstDecode::<crate::bindings::Amount>::cst_decode(*wrap).into()
9892 }
9893 }
9894 impl CstDecode<crate::model::AssetInfo> for *mut wire_cst_asset_info {
9895 fn cst_decode(self) -> crate::model::AssetInfo {
9897 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9898 CstDecode::<crate::model::AssetInfo>::cst_decode(*wrap).into()
9899 }
9900 }
9901 impl CstDecode<crate::model::BackupRequest> for *mut wire_cst_backup_request {
9902 fn cst_decode(self) -> crate::model::BackupRequest {
9904 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9905 CstDecode::<crate::model::BackupRequest>::cst_decode(*wrap).into()
9906 }
9907 }
9908 impl CstDecode<crate::bindings::BindingEventListener> for *mut wire_cst_binding_event_listener {
9909 fn cst_decode(self) -> crate::bindings::BindingEventListener {
9911 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9912 CstDecode::<crate::bindings::BindingEventListener>::cst_decode(*wrap).into()
9913 }
9914 }
9915 impl CstDecode<crate::bindings::BitcoinAddressData> for *mut wire_cst_bitcoin_address_data {
9916 fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9918 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9919 CstDecode::<crate::bindings::BitcoinAddressData>::cst_decode(*wrap).into()
9920 }
9921 }
9922 impl CstDecode<bool> for *mut bool {
9923 fn cst_decode(self) -> bool {
9925 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9926 }
9927 }
9928 impl CstDecode<crate::model::BuyBitcoinRequest> for *mut wire_cst_buy_bitcoin_request {
9929 fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
9931 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9932 CstDecode::<crate::model::BuyBitcoinRequest>::cst_decode(*wrap).into()
9933 }
9934 }
9935 impl CstDecode<crate::model::CheckMessageRequest> for *mut wire_cst_check_message_request {
9936 fn cst_decode(self) -> crate::model::CheckMessageRequest {
9938 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9939 CstDecode::<crate::model::CheckMessageRequest>::cst_decode(*wrap).into()
9940 }
9941 }
9942 impl CstDecode<crate::model::ConnectRequest> for *mut wire_cst_connect_request {
9943 fn cst_decode(self) -> crate::model::ConnectRequest {
9945 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9946 CstDecode::<crate::model::ConnectRequest>::cst_decode(*wrap).into()
9947 }
9948 }
9949 impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
9950 for *mut wire_cst_create_bolt_12_invoice_request
9951 {
9952 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
9954 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9955 CstDecode::<crate::model::CreateBolt12InvoiceRequest>::cst_decode(*wrap).into()
9956 }
9957 }
9958 impl CstDecode<f64> for *mut f64 {
9959 fn cst_decode(self) -> f64 {
9961 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9962 }
9963 }
9964 impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
9965 for *mut wire_cst_fetch_payment_proposed_fees_request
9966 {
9967 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
9969 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9970 CstDecode::<crate::model::FetchPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9971 }
9972 }
9973 impl CstDecode<crate::model::GetPaymentRequest> for *mut wire_cst_get_payment_request {
9974 fn cst_decode(self) -> crate::model::GetPaymentRequest {
9976 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9977 CstDecode::<crate::model::GetPaymentRequest>::cst_decode(*wrap).into()
9978 }
9979 }
9980 impl CstDecode<i64> for *mut i64 {
9981 fn cst_decode(self) -> i64 {
9983 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9984 }
9985 }
9986 impl CstDecode<crate::bindings::LiquidAddressData> for *mut wire_cst_liquid_address_data {
9987 fn cst_decode(self) -> crate::bindings::LiquidAddressData {
9989 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9990 CstDecode::<crate::bindings::LiquidAddressData>::cst_decode(*wrap).into()
9991 }
9992 }
9993 impl CstDecode<crate::model::ListPaymentDetails> for *mut wire_cst_list_payment_details {
9994 fn cst_decode(self) -> crate::model::ListPaymentDetails {
9996 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9997 CstDecode::<crate::model::ListPaymentDetails>::cst_decode(*wrap).into()
9998 }
9999 }
10000 impl CstDecode<crate::model::ListPaymentsRequest> for *mut wire_cst_list_payments_request {
10001 fn cst_decode(self) -> crate::model::ListPaymentsRequest {
10003 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10004 CstDecode::<crate::model::ListPaymentsRequest>::cst_decode(*wrap).into()
10005 }
10006 }
10007 impl CstDecode<crate::bindings::LNInvoice> for *mut wire_cst_ln_invoice {
10008 fn cst_decode(self) -> crate::bindings::LNInvoice {
10010 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10011 CstDecode::<crate::bindings::LNInvoice>::cst_decode(*wrap).into()
10012 }
10013 }
10014 impl CstDecode<crate::bindings::LNOffer> for *mut wire_cst_ln_offer {
10015 fn cst_decode(self) -> crate::bindings::LNOffer {
10017 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10018 CstDecode::<crate::bindings::LNOffer>::cst_decode(*wrap).into()
10019 }
10020 }
10021 impl CstDecode<crate::bindings::LnUrlAuthRequestData> for *mut wire_cst_ln_url_auth_request_data {
10022 fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10024 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10025 CstDecode::<crate::bindings::LnUrlAuthRequestData>::cst_decode(*wrap).into()
10026 }
10027 }
10028 impl CstDecode<crate::bindings::LnUrlErrorData> for *mut wire_cst_ln_url_error_data {
10029 fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10031 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10032 CstDecode::<crate::bindings::LnUrlErrorData>::cst_decode(*wrap).into()
10033 }
10034 }
10035 impl CstDecode<crate::model::LnUrlInfo> for *mut wire_cst_ln_url_info {
10036 fn cst_decode(self) -> crate::model::LnUrlInfo {
10038 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10039 CstDecode::<crate::model::LnUrlInfo>::cst_decode(*wrap).into()
10040 }
10041 }
10042 impl CstDecode<crate::bindings::LnUrlPayErrorData> for *mut wire_cst_ln_url_pay_error_data {
10043 fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10045 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10046 CstDecode::<crate::bindings::LnUrlPayErrorData>::cst_decode(*wrap).into()
10047 }
10048 }
10049 impl CstDecode<crate::model::LnUrlPayRequest> for *mut wire_cst_ln_url_pay_request {
10050 fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10052 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10053 CstDecode::<crate::model::LnUrlPayRequest>::cst_decode(*wrap).into()
10054 }
10055 }
10056 impl CstDecode<crate::bindings::LnUrlPayRequestData> for *mut wire_cst_ln_url_pay_request_data {
10057 fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10059 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10060 CstDecode::<crate::bindings::LnUrlPayRequestData>::cst_decode(*wrap).into()
10061 }
10062 }
10063 impl CstDecode<crate::model::LnUrlPaySuccessData> for *mut wire_cst_ln_url_pay_success_data {
10064 fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10066 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10067 CstDecode::<crate::model::LnUrlPaySuccessData>::cst_decode(*wrap).into()
10068 }
10069 }
10070 impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for *mut wire_cst_ln_url_withdraw_request {
10071 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
10073 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10074 CstDecode::<crate::bindings::LnUrlWithdrawRequest>::cst_decode(*wrap).into()
10075 }
10076 }
10077 impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
10078 for *mut wire_cst_ln_url_withdraw_request_data
10079 {
10080 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
10082 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10083 CstDecode::<crate::bindings::LnUrlWithdrawRequestData>::cst_decode(*wrap).into()
10084 }
10085 }
10086 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
10087 for *mut wire_cst_ln_url_withdraw_success_data
10088 {
10089 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
10091 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10092 CstDecode::<crate::bindings::duplicates::LnUrlWithdrawSuccessData>::cst_decode(*wrap)
10093 .into()
10094 }
10095 }
10096 impl CstDecode<crate::bindings::MessageSuccessActionData>
10097 for *mut wire_cst_message_success_action_data
10098 {
10099 fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
10101 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10102 CstDecode::<crate::bindings::MessageSuccessActionData>::cst_decode(*wrap).into()
10103 }
10104 }
10105 impl CstDecode<crate::model::PayAmount> for *mut wire_cst_pay_amount {
10106 fn cst_decode(self) -> crate::model::PayAmount {
10108 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10109 CstDecode::<crate::model::PayAmount>::cst_decode(*wrap).into()
10110 }
10111 }
10112 impl CstDecode<crate::model::PayOnchainRequest> for *mut wire_cst_pay_onchain_request {
10113 fn cst_decode(self) -> crate::model::PayOnchainRequest {
10115 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10116 CstDecode::<crate::model::PayOnchainRequest>::cst_decode(*wrap).into()
10117 }
10118 }
10119 impl CstDecode<crate::model::Payment> for *mut wire_cst_payment {
10120 fn cst_decode(self) -> crate::model::Payment {
10122 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10123 CstDecode::<crate::model::Payment>::cst_decode(*wrap).into()
10124 }
10125 }
10126 impl CstDecode<crate::model::PrepareBuyBitcoinRequest>
10127 for *mut wire_cst_prepare_buy_bitcoin_request
10128 {
10129 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
10131 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10132 CstDecode::<crate::model::PrepareBuyBitcoinRequest>::cst_decode(*wrap).into()
10133 }
10134 }
10135 impl CstDecode<crate::model::PrepareLnUrlPayRequest> for *mut wire_cst_prepare_ln_url_pay_request {
10136 fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
10138 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10139 CstDecode::<crate::model::PrepareLnUrlPayRequest>::cst_decode(*wrap).into()
10140 }
10141 }
10142 impl CstDecode<crate::model::PreparePayOnchainRequest>
10143 for *mut wire_cst_prepare_pay_onchain_request
10144 {
10145 fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
10147 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10148 CstDecode::<crate::model::PreparePayOnchainRequest>::cst_decode(*wrap).into()
10149 }
10150 }
10151 impl CstDecode<crate::model::PrepareReceiveRequest> for *mut wire_cst_prepare_receive_request {
10152 fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
10154 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10155 CstDecode::<crate::model::PrepareReceiveRequest>::cst_decode(*wrap).into()
10156 }
10157 }
10158 impl CstDecode<crate::model::PrepareRefundRequest> for *mut wire_cst_prepare_refund_request {
10159 fn cst_decode(self) -> crate::model::PrepareRefundRequest {
10161 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10162 CstDecode::<crate::model::PrepareRefundRequest>::cst_decode(*wrap).into()
10163 }
10164 }
10165 impl CstDecode<crate::model::PrepareSendRequest> for *mut wire_cst_prepare_send_request {
10166 fn cst_decode(self) -> crate::model::PrepareSendRequest {
10168 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10169 CstDecode::<crate::model::PrepareSendRequest>::cst_decode(*wrap).into()
10170 }
10171 }
10172 impl CstDecode<crate::model::ReceiveAmount> for *mut wire_cst_receive_amount {
10173 fn cst_decode(self) -> crate::model::ReceiveAmount {
10175 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10176 CstDecode::<crate::model::ReceiveAmount>::cst_decode(*wrap).into()
10177 }
10178 }
10179 impl CstDecode<crate::model::ReceivePaymentRequest> for *mut wire_cst_receive_payment_request {
10180 fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
10182 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10183 CstDecode::<crate::model::ReceivePaymentRequest>::cst_decode(*wrap).into()
10184 }
10185 }
10186 impl CstDecode<crate::model::RefundRequest> for *mut wire_cst_refund_request {
10187 fn cst_decode(self) -> crate::model::RefundRequest {
10189 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10190 CstDecode::<crate::model::RefundRequest>::cst_decode(*wrap).into()
10191 }
10192 }
10193 impl CstDecode<crate::model::RestoreRequest> for *mut wire_cst_restore_request {
10194 fn cst_decode(self) -> crate::model::RestoreRequest {
10196 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10197 CstDecode::<crate::model::RestoreRequest>::cst_decode(*wrap).into()
10198 }
10199 }
10200 impl CstDecode<crate::model::SdkEvent> for *mut wire_cst_sdk_event {
10201 fn cst_decode(self) -> crate::model::SdkEvent {
10203 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10204 CstDecode::<crate::model::SdkEvent>::cst_decode(*wrap).into()
10205 }
10206 }
10207 impl CstDecode<crate::model::SendPaymentRequest> for *mut wire_cst_send_payment_request {
10208 fn cst_decode(self) -> crate::model::SendPaymentRequest {
10210 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10211 CstDecode::<crate::model::SendPaymentRequest>::cst_decode(*wrap).into()
10212 }
10213 }
10214 impl CstDecode<crate::model::SignMessageRequest> for *mut wire_cst_sign_message_request {
10215 fn cst_decode(self) -> crate::model::SignMessageRequest {
10217 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10218 CstDecode::<crate::model::SignMessageRequest>::cst_decode(*wrap).into()
10219 }
10220 }
10221 impl CstDecode<crate::bindings::SuccessAction> for *mut wire_cst_success_action {
10222 fn cst_decode(self) -> crate::bindings::SuccessAction {
10224 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10225 CstDecode::<crate::bindings::SuccessAction>::cst_decode(*wrap).into()
10226 }
10227 }
10228 impl CstDecode<crate::bindings::SuccessActionProcessed> for *mut wire_cst_success_action_processed {
10229 fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
10231 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10232 CstDecode::<crate::bindings::SuccessActionProcessed>::cst_decode(*wrap).into()
10233 }
10234 }
10235 impl CstDecode<crate::bindings::Symbol> for *mut wire_cst_symbol {
10236 fn cst_decode(self) -> crate::bindings::Symbol {
10238 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10239 CstDecode::<crate::bindings::Symbol>::cst_decode(*wrap).into()
10240 }
10241 }
10242 impl CstDecode<u32> for *mut u32 {
10243 fn cst_decode(self) -> u32 {
10245 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10246 }
10247 }
10248 impl CstDecode<u64> for *mut u64 {
10249 fn cst_decode(self) -> u64 {
10251 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10252 }
10253 }
10254 impl CstDecode<crate::bindings::UrlSuccessActionData> for *mut wire_cst_url_success_action_data {
10255 fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
10257 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10258 CstDecode::<crate::bindings::UrlSuccessActionData>::cst_decode(*wrap).into()
10259 }
10260 }
10261 impl CstDecode<crate::model::BuyBitcoinRequest> for wire_cst_buy_bitcoin_request {
10262 fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
10264 crate::model::BuyBitcoinRequest {
10265 prepare_response: self.prepare_response.cst_decode(),
10266 redirect_url: self.redirect_url.cst_decode(),
10267 }
10268 }
10269 }
10270 impl CstDecode<crate::model::CheckMessageRequest> for wire_cst_check_message_request {
10271 fn cst_decode(self) -> crate::model::CheckMessageRequest {
10273 crate::model::CheckMessageRequest {
10274 message: self.message.cst_decode(),
10275 pubkey: self.pubkey.cst_decode(),
10276 signature: self.signature.cst_decode(),
10277 }
10278 }
10279 }
10280 impl CstDecode<crate::model::CheckMessageResponse> for wire_cst_check_message_response {
10281 fn cst_decode(self) -> crate::model::CheckMessageResponse {
10283 crate::model::CheckMessageResponse {
10284 is_valid: self.is_valid.cst_decode(),
10285 }
10286 }
10287 }
10288 impl CstDecode<crate::model::Config> for wire_cst_config {
10289 fn cst_decode(self) -> crate::model::Config {
10291 crate::model::Config {
10292 liquid_explorer: self.liquid_explorer.cst_decode(),
10293 bitcoin_explorer: self.bitcoin_explorer.cst_decode(),
10294 working_dir: self.working_dir.cst_decode(),
10295 network: self.network.cst_decode(),
10296 payment_timeout_sec: self.payment_timeout_sec.cst_decode(),
10297 sync_service_url: self.sync_service_url.cst_decode(),
10298 zero_conf_max_amount_sat: self.zero_conf_max_amount_sat.cst_decode(),
10299 breez_api_key: self.breez_api_key.cst_decode(),
10300 external_input_parsers: self.external_input_parsers.cst_decode(),
10301 use_default_external_input_parsers: self
10302 .use_default_external_input_parsers
10303 .cst_decode(),
10304 onchain_fee_rate_leeway_sat: self.onchain_fee_rate_leeway_sat.cst_decode(),
10305 asset_metadata: self.asset_metadata.cst_decode(),
10306 sideswap_api_key: self.sideswap_api_key.cst_decode(),
10307 use_magic_routing_hints: self.use_magic_routing_hints.cst_decode(),
10308 }
10309 }
10310 }
10311 impl CstDecode<crate::model::ConnectRequest> for wire_cst_connect_request {
10312 fn cst_decode(self) -> crate::model::ConnectRequest {
10314 crate::model::ConnectRequest {
10315 config: self.config.cst_decode(),
10316 mnemonic: self.mnemonic.cst_decode(),
10317 passphrase: self.passphrase.cst_decode(),
10318 seed: self.seed.cst_decode(),
10319 }
10320 }
10321 }
10322 impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
10323 for wire_cst_create_bolt_12_invoice_request
10324 {
10325 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
10327 crate::model::CreateBolt12InvoiceRequest {
10328 offer: self.offer.cst_decode(),
10329 invoice_request: self.invoice_request.cst_decode(),
10330 }
10331 }
10332 }
10333 impl CstDecode<crate::model::CreateBolt12InvoiceResponse>
10334 for wire_cst_create_bolt_12_invoice_response
10335 {
10336 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceResponse {
10338 crate::model::CreateBolt12InvoiceResponse {
10339 invoice: self.invoice.cst_decode(),
10340 }
10341 }
10342 }
10343 impl CstDecode<crate::bindings::CurrencyInfo> for wire_cst_currency_info {
10344 fn cst_decode(self) -> crate::bindings::CurrencyInfo {
10346 crate::bindings::CurrencyInfo {
10347 name: self.name.cst_decode(),
10348 fraction_size: self.fraction_size.cst_decode(),
10349 spacing: self.spacing.cst_decode(),
10350 symbol: self.symbol.cst_decode(),
10351 uniq_symbol: self.uniq_symbol.cst_decode(),
10352 localized_name: self.localized_name.cst_decode(),
10353 locale_overrides: self.locale_overrides.cst_decode(),
10354 }
10355 }
10356 }
10357 impl CstDecode<crate::bindings::ExternalInputParser> for wire_cst_external_input_parser {
10358 fn cst_decode(self) -> crate::bindings::ExternalInputParser {
10360 crate::bindings::ExternalInputParser {
10361 provider_id: self.provider_id.cst_decode(),
10362 input_regex: self.input_regex.cst_decode(),
10363 parser_url: self.parser_url.cst_decode(),
10364 }
10365 }
10366 }
10367 impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
10368 for wire_cst_fetch_payment_proposed_fees_request
10369 {
10370 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
10372 crate::model::FetchPaymentProposedFeesRequest {
10373 swap_id: self.swap_id.cst_decode(),
10374 }
10375 }
10376 }
10377 impl CstDecode<crate::model::FetchPaymentProposedFeesResponse>
10378 for wire_cst_fetch_payment_proposed_fees_response
10379 {
10380 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesResponse {
10382 crate::model::FetchPaymentProposedFeesResponse {
10383 swap_id: self.swap_id.cst_decode(),
10384 fees_sat: self.fees_sat.cst_decode(),
10385 payer_amount_sat: self.payer_amount_sat.cst_decode(),
10386 receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
10387 }
10388 }
10389 }
10390 impl CstDecode<crate::bindings::FiatCurrency> for wire_cst_fiat_currency {
10391 fn cst_decode(self) -> crate::bindings::FiatCurrency {
10393 crate::bindings::FiatCurrency {
10394 id: self.id.cst_decode(),
10395 info: self.info.cst_decode(),
10396 }
10397 }
10398 }
10399 impl CstDecode<crate::model::GetInfoResponse> for wire_cst_get_info_response {
10400 fn cst_decode(self) -> crate::model::GetInfoResponse {
10402 crate::model::GetInfoResponse {
10403 wallet_info: self.wallet_info.cst_decode(),
10404 blockchain_info: self.blockchain_info.cst_decode(),
10405 }
10406 }
10407 }
10408 impl CstDecode<crate::model::GetPaymentRequest> for wire_cst_get_payment_request {
10409 fn cst_decode(self) -> crate::model::GetPaymentRequest {
10411 match self.tag {
10412 0 => {
10413 let ans = unsafe { self.kind.PaymentHash };
10414 crate::model::GetPaymentRequest::PaymentHash {
10415 payment_hash: ans.payment_hash.cst_decode(),
10416 }
10417 }
10418 1 => {
10419 let ans = unsafe { self.kind.SwapId };
10420 crate::model::GetPaymentRequest::SwapId {
10421 swap_id: ans.swap_id.cst_decode(),
10422 }
10423 }
10424 _ => unreachable!(),
10425 }
10426 }
10427 }
10428 impl CstDecode<crate::bindings::InputType> for wire_cst_input_type {
10429 fn cst_decode(self) -> crate::bindings::InputType {
10431 match self.tag {
10432 0 => {
10433 let ans = unsafe { self.kind.BitcoinAddress };
10434 crate::bindings::InputType::BitcoinAddress {
10435 address: ans.address.cst_decode(),
10436 }
10437 }
10438 1 => {
10439 let ans = unsafe { self.kind.LiquidAddress };
10440 crate::bindings::InputType::LiquidAddress {
10441 address: ans.address.cst_decode(),
10442 }
10443 }
10444 2 => {
10445 let ans = unsafe { self.kind.Bolt11 };
10446 crate::bindings::InputType::Bolt11 {
10447 invoice: ans.invoice.cst_decode(),
10448 }
10449 }
10450 3 => {
10451 let ans = unsafe { self.kind.Bolt12Offer };
10452 crate::bindings::InputType::Bolt12Offer {
10453 offer: ans.offer.cst_decode(),
10454 bip353_address: ans.bip353_address.cst_decode(),
10455 }
10456 }
10457 4 => {
10458 let ans = unsafe { self.kind.NodeId };
10459 crate::bindings::InputType::NodeId {
10460 node_id: ans.node_id.cst_decode(),
10461 }
10462 }
10463 5 => {
10464 let ans = unsafe { self.kind.Url };
10465 crate::bindings::InputType::Url {
10466 url: ans.url.cst_decode(),
10467 }
10468 }
10469 6 => {
10470 let ans = unsafe { self.kind.LnUrlPay };
10471 crate::bindings::InputType::LnUrlPay {
10472 data: ans.data.cst_decode(),
10473 bip353_address: ans.bip353_address.cst_decode(),
10474 }
10475 }
10476 7 => {
10477 let ans = unsafe { self.kind.LnUrlWithdraw };
10478 crate::bindings::InputType::LnUrlWithdraw {
10479 data: ans.data.cst_decode(),
10480 }
10481 }
10482 8 => {
10483 let ans = unsafe { self.kind.LnUrlAuth };
10484 crate::bindings::InputType::LnUrlAuth {
10485 data: ans.data.cst_decode(),
10486 }
10487 }
10488 9 => {
10489 let ans = unsafe { self.kind.LnUrlError };
10490 crate::bindings::InputType::LnUrlError {
10491 data: ans.data.cst_decode(),
10492 }
10493 }
10494 _ => unreachable!(),
10495 }
10496 }
10497 }
10498 impl CstDecode<crate::model::LightningPaymentLimitsResponse>
10499 for wire_cst_lightning_payment_limits_response
10500 {
10501 fn cst_decode(self) -> crate::model::LightningPaymentLimitsResponse {
10503 crate::model::LightningPaymentLimitsResponse {
10504 send: self.send.cst_decode(),
10505 receive: self.receive.cst_decode(),
10506 }
10507 }
10508 }
10509 impl CstDecode<crate::model::Limits> for wire_cst_limits {
10510 fn cst_decode(self) -> crate::model::Limits {
10512 crate::model::Limits {
10513 min_sat: self.min_sat.cst_decode(),
10514 max_sat: self.max_sat.cst_decode(),
10515 max_zero_conf_sat: self.max_zero_conf_sat.cst_decode(),
10516 }
10517 }
10518 }
10519 impl CstDecode<crate::bindings::LiquidAddressData> for wire_cst_liquid_address_data {
10520 fn cst_decode(self) -> crate::bindings::LiquidAddressData {
10522 crate::bindings::LiquidAddressData {
10523 address: self.address.cst_decode(),
10524 network: self.network.cst_decode(),
10525 asset_id: self.asset_id.cst_decode(),
10526 amount: self.amount.cst_decode(),
10527 amount_sat: self.amount_sat.cst_decode(),
10528 label: self.label.cst_decode(),
10529 message: self.message.cst_decode(),
10530 }
10531 }
10532 }
10533 impl CstDecode<Vec<String>> for *mut wire_cst_list_String {
10534 fn cst_decode(self) -> Vec<String> {
10536 let vec = unsafe {
10537 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10538 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10539 };
10540 vec.into_iter().map(CstDecode::cst_decode).collect()
10541 }
10542 }
10543 impl CstDecode<Vec<crate::model::AssetBalance>> for *mut wire_cst_list_asset_balance {
10544 fn cst_decode(self) -> Vec<crate::model::AssetBalance> {
10546 let vec = unsafe {
10547 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10548 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10549 };
10550 vec.into_iter().map(CstDecode::cst_decode).collect()
10551 }
10552 }
10553 impl CstDecode<Vec<crate::model::AssetMetadata>> for *mut wire_cst_list_asset_metadata {
10554 fn cst_decode(self) -> Vec<crate::model::AssetMetadata> {
10556 let vec = unsafe {
10557 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10558 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10559 };
10560 vec.into_iter().map(CstDecode::cst_decode).collect()
10561 }
10562 }
10563 impl CstDecode<Vec<crate::bindings::ExternalInputParser>>
10564 for *mut wire_cst_list_external_input_parser
10565 {
10566 fn cst_decode(self) -> Vec<crate::bindings::ExternalInputParser> {
10568 let vec = unsafe {
10569 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10570 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10571 };
10572 vec.into_iter().map(CstDecode::cst_decode).collect()
10573 }
10574 }
10575 impl CstDecode<Vec<crate::bindings::FiatCurrency>> for *mut wire_cst_list_fiat_currency {
10576 fn cst_decode(self) -> Vec<crate::bindings::FiatCurrency> {
10578 let vec = unsafe {
10579 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10580 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10581 };
10582 vec.into_iter().map(CstDecode::cst_decode).collect()
10583 }
10584 }
10585 impl CstDecode<Vec<crate::bindings::LnOfferBlindedPath>>
10586 for *mut wire_cst_list_ln_offer_blinded_path
10587 {
10588 fn cst_decode(self) -> Vec<crate::bindings::LnOfferBlindedPath> {
10590 let vec = unsafe {
10591 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10592 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10593 };
10594 vec.into_iter().map(CstDecode::cst_decode).collect()
10595 }
10596 }
10597 impl CstDecode<Vec<crate::bindings::LocaleOverrides>> for *mut wire_cst_list_locale_overrides {
10598 fn cst_decode(self) -> Vec<crate::bindings::LocaleOverrides> {
10600 let vec = unsafe {
10601 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10602 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10603 };
10604 vec.into_iter().map(CstDecode::cst_decode).collect()
10605 }
10606 }
10607 impl CstDecode<Vec<crate::bindings::LocalizedName>> for *mut wire_cst_list_localized_name {
10608 fn cst_decode(self) -> Vec<crate::bindings::LocalizedName> {
10610 let vec = unsafe {
10611 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10612 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10613 };
10614 vec.into_iter().map(CstDecode::cst_decode).collect()
10615 }
10616 }
10617 impl CstDecode<Vec<crate::model::Payment>> for *mut wire_cst_list_payment {
10618 fn cst_decode(self) -> Vec<crate::model::Payment> {
10620 let vec = unsafe {
10621 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10622 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10623 };
10624 vec.into_iter().map(CstDecode::cst_decode).collect()
10625 }
10626 }
10627 impl CstDecode<crate::model::ListPaymentDetails> for wire_cst_list_payment_details {
10628 fn cst_decode(self) -> crate::model::ListPaymentDetails {
10630 match self.tag {
10631 0 => {
10632 let ans = unsafe { self.kind.Liquid };
10633 crate::model::ListPaymentDetails::Liquid {
10634 asset_id: ans.asset_id.cst_decode(),
10635 destination: ans.destination.cst_decode(),
10636 }
10637 }
10638 1 => {
10639 let ans = unsafe { self.kind.Bitcoin };
10640 crate::model::ListPaymentDetails::Bitcoin {
10641 address: ans.address.cst_decode(),
10642 }
10643 }
10644 _ => unreachable!(),
10645 }
10646 }
10647 }
10648 impl CstDecode<Vec<crate::model::PaymentState>> for *mut wire_cst_list_payment_state {
10649 fn cst_decode(self) -> Vec<crate::model::PaymentState> {
10651 let vec = unsafe {
10652 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10653 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10654 };
10655 vec.into_iter().map(CstDecode::cst_decode).collect()
10656 }
10657 }
10658 impl CstDecode<Vec<crate::model::PaymentType>> for *mut wire_cst_list_payment_type {
10659 fn cst_decode(self) -> Vec<crate::model::PaymentType> {
10661 let vec = unsafe {
10662 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10663 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10664 };
10665 vec.into_iter().map(CstDecode::cst_decode).collect()
10666 }
10667 }
10668 impl CstDecode<crate::model::ListPaymentsRequest> for wire_cst_list_payments_request {
10669 fn cst_decode(self) -> crate::model::ListPaymentsRequest {
10671 crate::model::ListPaymentsRequest {
10672 filters: self.filters.cst_decode(),
10673 states: self.states.cst_decode(),
10674 from_timestamp: self.from_timestamp.cst_decode(),
10675 to_timestamp: self.to_timestamp.cst_decode(),
10676 offset: self.offset.cst_decode(),
10677 limit: self.limit.cst_decode(),
10678 details: self.details.cst_decode(),
10679 sort_ascending: self.sort_ascending.cst_decode(),
10680 }
10681 }
10682 }
10683 impl CstDecode<Vec<u8>> for *mut wire_cst_list_prim_u_8_strict {
10684 fn cst_decode(self) -> Vec<u8> {
10686 unsafe {
10687 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10688 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10689 }
10690 }
10691 }
10692 impl CstDecode<Vec<crate::bindings::Rate>> for *mut wire_cst_list_rate {
10693 fn cst_decode(self) -> Vec<crate::bindings::Rate> {
10695 let vec = unsafe {
10696 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10697 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10698 };
10699 vec.into_iter().map(CstDecode::cst_decode).collect()
10700 }
10701 }
10702 impl CstDecode<Vec<crate::model::RefundableSwap>> for *mut wire_cst_list_refundable_swap {
10703 fn cst_decode(self) -> Vec<crate::model::RefundableSwap> {
10705 let vec = unsafe {
10706 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10707 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10708 };
10709 vec.into_iter().map(CstDecode::cst_decode).collect()
10710 }
10711 }
10712 impl CstDecode<Vec<crate::bindings::RouteHint>> for *mut wire_cst_list_route_hint {
10713 fn cst_decode(self) -> Vec<crate::bindings::RouteHint> {
10715 let vec = unsafe {
10716 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10717 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10718 };
10719 vec.into_iter().map(CstDecode::cst_decode).collect()
10720 }
10721 }
10722 impl CstDecode<Vec<crate::bindings::RouteHintHop>> for *mut wire_cst_list_route_hint_hop {
10723 fn cst_decode(self) -> Vec<crate::bindings::RouteHintHop> {
10725 let vec = unsafe {
10726 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10727 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10728 };
10729 vec.into_iter().map(CstDecode::cst_decode).collect()
10730 }
10731 }
10732 impl CstDecode<crate::bindings::LNInvoice> for wire_cst_ln_invoice {
10733 fn cst_decode(self) -> crate::bindings::LNInvoice {
10735 crate::bindings::LNInvoice {
10736 bolt11: self.bolt11.cst_decode(),
10737 network: self.network.cst_decode(),
10738 payee_pubkey: self.payee_pubkey.cst_decode(),
10739 payment_hash: self.payment_hash.cst_decode(),
10740 description: self.description.cst_decode(),
10741 description_hash: self.description_hash.cst_decode(),
10742 amount_msat: self.amount_msat.cst_decode(),
10743 timestamp: self.timestamp.cst_decode(),
10744 expiry: self.expiry.cst_decode(),
10745 routing_hints: self.routing_hints.cst_decode(),
10746 payment_secret: self.payment_secret.cst_decode(),
10747 min_final_cltv_expiry_delta: self.min_final_cltv_expiry_delta.cst_decode(),
10748 }
10749 }
10750 }
10751 impl CstDecode<crate::bindings::LNOffer> for wire_cst_ln_offer {
10752 fn cst_decode(self) -> crate::bindings::LNOffer {
10754 crate::bindings::LNOffer {
10755 offer: self.offer.cst_decode(),
10756 chains: self.chains.cst_decode(),
10757 min_amount: self.min_amount.cst_decode(),
10758 description: self.description.cst_decode(),
10759 absolute_expiry: self.absolute_expiry.cst_decode(),
10760 issuer: self.issuer.cst_decode(),
10761 signing_pubkey: self.signing_pubkey.cst_decode(),
10762 paths: self.paths.cst_decode(),
10763 }
10764 }
10765 }
10766 impl CstDecode<crate::bindings::LnOfferBlindedPath> for wire_cst_ln_offer_blinded_path {
10767 fn cst_decode(self) -> crate::bindings::LnOfferBlindedPath {
10769 crate::bindings::LnOfferBlindedPath {
10770 blinded_hops: self.blinded_hops.cst_decode(),
10771 }
10772 }
10773 }
10774 impl CstDecode<crate::bindings::duplicates::LnUrlAuthError> for wire_cst_ln_url_auth_error {
10775 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlAuthError {
10777 match self.tag {
10778 0 => {
10779 let ans = unsafe { self.kind.Generic };
10780 crate::bindings::duplicates::LnUrlAuthError::Generic {
10781 err: ans.err.cst_decode(),
10782 }
10783 }
10784 1 => {
10785 let ans = unsafe { self.kind.InvalidUri };
10786 crate::bindings::duplicates::LnUrlAuthError::InvalidUri {
10787 err: ans.err.cst_decode(),
10788 }
10789 }
10790 2 => {
10791 let ans = unsafe { self.kind.ServiceConnectivity };
10792 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
10793 err: ans.err.cst_decode(),
10794 }
10795 }
10796 _ => unreachable!(),
10797 }
10798 }
10799 }
10800 impl CstDecode<crate::bindings::LnUrlAuthRequestData> for wire_cst_ln_url_auth_request_data {
10801 fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10803 crate::bindings::LnUrlAuthRequestData {
10804 k1: self.k1.cst_decode(),
10805 action: self.action.cst_decode(),
10806 domain: self.domain.cst_decode(),
10807 url: self.url.cst_decode(),
10808 }
10809 }
10810 }
10811 impl CstDecode<crate::bindings::duplicates::LnUrlCallbackStatus>
10812 for wire_cst_ln_url_callback_status
10813 {
10814 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
10816 match self.tag {
10817 0 => crate::bindings::duplicates::LnUrlCallbackStatus::Ok,
10818 1 => {
10819 let ans = unsafe { self.kind.ErrorStatus };
10820 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
10821 data: ans.data.cst_decode(),
10822 }
10823 }
10824 _ => unreachable!(),
10825 }
10826 }
10827 }
10828 impl CstDecode<crate::bindings::LnUrlErrorData> for wire_cst_ln_url_error_data {
10829 fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10831 crate::bindings::LnUrlErrorData {
10832 reason: self.reason.cst_decode(),
10833 }
10834 }
10835 }
10836 impl CstDecode<crate::model::LnUrlInfo> for wire_cst_ln_url_info {
10837 fn cst_decode(self) -> crate::model::LnUrlInfo {
10839 crate::model::LnUrlInfo {
10840 ln_address: self.ln_address.cst_decode(),
10841 lnurl_pay_comment: self.lnurl_pay_comment.cst_decode(),
10842 lnurl_pay_domain: self.lnurl_pay_domain.cst_decode(),
10843 lnurl_pay_metadata: self.lnurl_pay_metadata.cst_decode(),
10844 lnurl_pay_success_action: self.lnurl_pay_success_action.cst_decode(),
10845 lnurl_pay_unprocessed_success_action: self
10846 .lnurl_pay_unprocessed_success_action
10847 .cst_decode(),
10848 lnurl_withdraw_endpoint: self.lnurl_withdraw_endpoint.cst_decode(),
10849 }
10850 }
10851 }
10852 impl CstDecode<crate::bindings::duplicates::LnUrlPayError> for wire_cst_ln_url_pay_error {
10853 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlPayError {
10855 match self.tag {
10856 0 => crate::bindings::duplicates::LnUrlPayError::AlreadyPaid,
10857 1 => {
10858 let ans = unsafe { self.kind.Generic };
10859 crate::bindings::duplicates::LnUrlPayError::Generic {
10860 err: ans.err.cst_decode(),
10861 }
10862 }
10863 2 => {
10864 let ans = unsafe { self.kind.InsufficientBalance };
10865 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
10866 err: ans.err.cst_decode(),
10867 }
10868 }
10869 3 => {
10870 let ans = unsafe { self.kind.InvalidAmount };
10871 crate::bindings::duplicates::LnUrlPayError::InvalidAmount {
10872 err: ans.err.cst_decode(),
10873 }
10874 }
10875 4 => {
10876 let ans = unsafe { self.kind.InvalidInvoice };
10877 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice {
10878 err: ans.err.cst_decode(),
10879 }
10880 }
10881 5 => {
10882 let ans = unsafe { self.kind.InvalidNetwork };
10883 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork {
10884 err: ans.err.cst_decode(),
10885 }
10886 }
10887 6 => {
10888 let ans = unsafe { self.kind.InvalidUri };
10889 crate::bindings::duplicates::LnUrlPayError::InvalidUri {
10890 err: ans.err.cst_decode(),
10891 }
10892 }
10893 7 => {
10894 let ans = unsafe { self.kind.InvoiceExpired };
10895 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired {
10896 err: ans.err.cst_decode(),
10897 }
10898 }
10899 8 => {
10900 let ans = unsafe { self.kind.PaymentFailed };
10901 crate::bindings::duplicates::LnUrlPayError::PaymentFailed {
10902 err: ans.err.cst_decode(),
10903 }
10904 }
10905 9 => {
10906 let ans = unsafe { self.kind.PaymentTimeout };
10907 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout {
10908 err: ans.err.cst_decode(),
10909 }
10910 }
10911 10 => {
10912 let ans = unsafe { self.kind.RouteNotFound };
10913 crate::bindings::duplicates::LnUrlPayError::RouteNotFound {
10914 err: ans.err.cst_decode(),
10915 }
10916 }
10917 11 => {
10918 let ans = unsafe { self.kind.RouteTooExpensive };
10919 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
10920 err: ans.err.cst_decode(),
10921 }
10922 }
10923 12 => {
10924 let ans = unsafe { self.kind.ServiceConnectivity };
10925 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
10926 err: ans.err.cst_decode(),
10927 }
10928 }
10929 _ => unreachable!(),
10930 }
10931 }
10932 }
10933 impl CstDecode<crate::bindings::LnUrlPayErrorData> for wire_cst_ln_url_pay_error_data {
10934 fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10936 crate::bindings::LnUrlPayErrorData {
10937 payment_hash: self.payment_hash.cst_decode(),
10938 reason: self.reason.cst_decode(),
10939 }
10940 }
10941 }
10942 impl CstDecode<crate::model::LnUrlPayRequest> for wire_cst_ln_url_pay_request {
10943 fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10945 crate::model::LnUrlPayRequest {
10946 prepare_response: self.prepare_response.cst_decode(),
10947 }
10948 }
10949 }
10950 impl CstDecode<crate::bindings::LnUrlPayRequestData> for wire_cst_ln_url_pay_request_data {
10951 fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10953 crate::bindings::LnUrlPayRequestData {
10954 callback: self.callback.cst_decode(),
10955 min_sendable: self.min_sendable.cst_decode(),
10956 max_sendable: self.max_sendable.cst_decode(),
10957 metadata_str: self.metadata_str.cst_decode(),
10958 comment_allowed: self.comment_allowed.cst_decode(),
10959 domain: self.domain.cst_decode(),
10960 allows_nostr: self.allows_nostr.cst_decode(),
10961 nostr_pubkey: self.nostr_pubkey.cst_decode(),
10962 ln_address: self.ln_address.cst_decode(),
10963 }
10964 }
10965 }
10966 impl CstDecode<crate::model::LnUrlPayResult> for wire_cst_ln_url_pay_result {
10967 fn cst_decode(self) -> crate::model::LnUrlPayResult {
10969 match self.tag {
10970 0 => {
10971 let ans = unsafe { self.kind.EndpointSuccess };
10972 crate::model::LnUrlPayResult::EndpointSuccess {
10973 data: ans.data.cst_decode(),
10974 }
10975 }
10976 1 => {
10977 let ans = unsafe { self.kind.EndpointError };
10978 crate::model::LnUrlPayResult::EndpointError {
10979 data: ans.data.cst_decode(),
10980 }
10981 }
10982 2 => {
10983 let ans = unsafe { self.kind.PayError };
10984 crate::model::LnUrlPayResult::PayError {
10985 data: ans.data.cst_decode(),
10986 }
10987 }
10988 _ => unreachable!(),
10989 }
10990 }
10991 }
10992 impl CstDecode<crate::model::LnUrlPaySuccessData> for wire_cst_ln_url_pay_success_data {
10993 fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10995 crate::model::LnUrlPaySuccessData {
10996 payment: self.payment.cst_decode(),
10997 success_action: self.success_action.cst_decode(),
10998 }
10999 }
11000 }
11001 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawError> for wire_cst_ln_url_withdraw_error {
11002 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
11004 match self.tag {
11005 0 => {
11006 let ans = unsafe { self.kind.Generic };
11007 crate::bindings::duplicates::LnUrlWithdrawError::Generic {
11008 err: ans.err.cst_decode(),
11009 }
11010 }
11011 1 => {
11012 let ans = unsafe { self.kind.InvalidAmount };
11013 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
11014 err: ans.err.cst_decode(),
11015 }
11016 }
11017 2 => {
11018 let ans = unsafe { self.kind.InvalidInvoice };
11019 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
11020 err: ans.err.cst_decode(),
11021 }
11022 }
11023 3 => {
11024 let ans = unsafe { self.kind.InvalidUri };
11025 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
11026 err: ans.err.cst_decode(),
11027 }
11028 }
11029 4 => {
11030 let ans = unsafe { self.kind.InvoiceNoRoutingHints };
11031 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
11032 err: ans.err.cst_decode(),
11033 }
11034 }
11035 5 => {
11036 let ans = unsafe { self.kind.ServiceConnectivity };
11037 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
11038 err: ans.err.cst_decode(),
11039 }
11040 }
11041 _ => unreachable!(),
11042 }
11043 }
11044 }
11045 impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for wire_cst_ln_url_withdraw_request {
11046 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
11048 crate::bindings::LnUrlWithdrawRequest {
11049 data: self.data.cst_decode(),
11050 amount_msat: self.amount_msat.cst_decode(),
11051 description: self.description.cst_decode(),
11052 }
11053 }
11054 }
11055 impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
11056 for wire_cst_ln_url_withdraw_request_data
11057 {
11058 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
11060 crate::bindings::LnUrlWithdrawRequestData {
11061 callback: self.callback.cst_decode(),
11062 k1: self.k1.cst_decode(),
11063 default_description: self.default_description.cst_decode(),
11064 min_withdrawable: self.min_withdrawable.cst_decode(),
11065 max_withdrawable: self.max_withdrawable.cst_decode(),
11066 }
11067 }
11068 }
11069 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawResult>
11070 for wire_cst_ln_url_withdraw_result
11071 {
11072 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
11074 match self.tag {
11075 0 => {
11076 let ans = unsafe { self.kind.Ok };
11077 crate::bindings::duplicates::LnUrlWithdrawResult::Ok {
11078 data: ans.data.cst_decode(),
11079 }
11080 }
11081 1 => {
11082 let ans = unsafe { self.kind.Timeout };
11083 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
11084 data: ans.data.cst_decode(),
11085 }
11086 }
11087 2 => {
11088 let ans = unsafe { self.kind.ErrorStatus };
11089 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
11090 data: ans.data.cst_decode(),
11091 }
11092 }
11093 _ => unreachable!(),
11094 }
11095 }
11096 }
11097 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
11098 for wire_cst_ln_url_withdraw_success_data
11099 {
11100 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11102 crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11103 invoice: self.invoice.cst_decode(),
11104 }
11105 }
11106 }
11107 impl CstDecode<crate::bindings::LocaleOverrides> for wire_cst_locale_overrides {
11108 fn cst_decode(self) -> crate::bindings::LocaleOverrides {
11110 crate::bindings::LocaleOverrides {
11111 locale: self.locale.cst_decode(),
11112 spacing: self.spacing.cst_decode(),
11113 symbol: self.symbol.cst_decode(),
11114 }
11115 }
11116 }
11117 impl CstDecode<crate::bindings::LocalizedName> for wire_cst_localized_name {
11118 fn cst_decode(self) -> crate::bindings::LocalizedName {
11120 crate::bindings::LocalizedName {
11121 locale: self.locale.cst_decode(),
11122 name: self.name.cst_decode(),
11123 }
11124 }
11125 }
11126 impl CstDecode<crate::model::LogEntry> for wire_cst_log_entry {
11127 fn cst_decode(self) -> crate::model::LogEntry {
11129 crate::model::LogEntry {
11130 line: self.line.cst_decode(),
11131 level: self.level.cst_decode(),
11132 }
11133 }
11134 }
11135 impl CstDecode<crate::bindings::MessageSuccessActionData> for wire_cst_message_success_action_data {
11136 fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
11138 crate::bindings::MessageSuccessActionData {
11139 message: self.message.cst_decode(),
11140 }
11141 }
11142 }
11143 impl CstDecode<crate::model::OnchainPaymentLimitsResponse>
11144 for wire_cst_onchain_payment_limits_response
11145 {
11146 fn cst_decode(self) -> crate::model::OnchainPaymentLimitsResponse {
11148 crate::model::OnchainPaymentLimitsResponse {
11149 send: self.send.cst_decode(),
11150 receive: self.receive.cst_decode(),
11151 }
11152 }
11153 }
11154 impl CstDecode<crate::model::PayAmount> for wire_cst_pay_amount {
11155 fn cst_decode(self) -> crate::model::PayAmount {
11157 match self.tag {
11158 0 => {
11159 let ans = unsafe { self.kind.Bitcoin };
11160 crate::model::PayAmount::Bitcoin {
11161 receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11162 }
11163 }
11164 1 => {
11165 let ans = unsafe { self.kind.Asset };
11166 crate::model::PayAmount::Asset {
11167 to_asset: ans.to_asset.cst_decode(),
11168 receiver_amount: ans.receiver_amount.cst_decode(),
11169 estimate_asset_fees: ans.estimate_asset_fees.cst_decode(),
11170 from_asset: ans.from_asset.cst_decode(),
11171 }
11172 }
11173 2 => crate::model::PayAmount::Drain,
11174 _ => unreachable!(),
11175 }
11176 }
11177 }
11178 impl CstDecode<crate::model::PayOnchainRequest> for wire_cst_pay_onchain_request {
11179 fn cst_decode(self) -> crate::model::PayOnchainRequest {
11181 crate::model::PayOnchainRequest {
11182 address: self.address.cst_decode(),
11183 prepare_response: self.prepare_response.cst_decode(),
11184 }
11185 }
11186 }
11187 impl CstDecode<crate::model::Payment> for wire_cst_payment {
11188 fn cst_decode(self) -> crate::model::Payment {
11190 crate::model::Payment {
11191 destination: self.destination.cst_decode(),
11192 tx_id: self.tx_id.cst_decode(),
11193 unblinding_data: self.unblinding_data.cst_decode(),
11194 timestamp: self.timestamp.cst_decode(),
11195 amount_sat: self.amount_sat.cst_decode(),
11196 fees_sat: self.fees_sat.cst_decode(),
11197 swapper_fees_sat: self.swapper_fees_sat.cst_decode(),
11198 payment_type: self.payment_type.cst_decode(),
11199 status: self.status.cst_decode(),
11200 details: self.details.cst_decode(),
11201 }
11202 }
11203 }
11204 impl CstDecode<crate::model::PaymentDetails> for wire_cst_payment_details {
11205 fn cst_decode(self) -> crate::model::PaymentDetails {
11207 match self.tag {
11208 0 => {
11209 let ans = unsafe { self.kind.Lightning };
11210 crate::model::PaymentDetails::Lightning {
11211 swap_id: ans.swap_id.cst_decode(),
11212 description: ans.description.cst_decode(),
11213 liquid_expiration_blockheight: ans
11214 .liquid_expiration_blockheight
11215 .cst_decode(),
11216 preimage: ans.preimage.cst_decode(),
11217 invoice: ans.invoice.cst_decode(),
11218 bolt12_offer: ans.bolt12_offer.cst_decode(),
11219 payment_hash: ans.payment_hash.cst_decode(),
11220 destination_pubkey: ans.destination_pubkey.cst_decode(),
11221 lnurl_info: ans.lnurl_info.cst_decode(),
11222 bip353_address: ans.bip353_address.cst_decode(),
11223 payer_note: ans.payer_note.cst_decode(),
11224 claim_tx_id: ans.claim_tx_id.cst_decode(),
11225 refund_tx_id: ans.refund_tx_id.cst_decode(),
11226 refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11227 }
11228 }
11229 1 => {
11230 let ans = unsafe { self.kind.Liquid };
11231 crate::model::PaymentDetails::Liquid {
11232 destination: ans.destination.cst_decode(),
11233 description: ans.description.cst_decode(),
11234 asset_id: ans.asset_id.cst_decode(),
11235 asset_info: ans.asset_info.cst_decode(),
11236 lnurl_info: ans.lnurl_info.cst_decode(),
11237 bip353_address: ans.bip353_address.cst_decode(),
11238 payer_note: ans.payer_note.cst_decode(),
11239 }
11240 }
11241 2 => {
11242 let ans = unsafe { self.kind.Bitcoin };
11243 crate::model::PaymentDetails::Bitcoin {
11244 swap_id: ans.swap_id.cst_decode(),
11245 bitcoin_address: ans.bitcoin_address.cst_decode(),
11246 description: ans.description.cst_decode(),
11247 auto_accepted_fees: ans.auto_accepted_fees.cst_decode(),
11248 liquid_expiration_blockheight: ans
11249 .liquid_expiration_blockheight
11250 .cst_decode(),
11251 bitcoin_expiration_blockheight: ans
11252 .bitcoin_expiration_blockheight
11253 .cst_decode(),
11254 lockup_tx_id: ans.lockup_tx_id.cst_decode(),
11255 claim_tx_id: ans.claim_tx_id.cst_decode(),
11256 refund_tx_id: ans.refund_tx_id.cst_decode(),
11257 refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11258 }
11259 }
11260 _ => unreachable!(),
11261 }
11262 }
11263 }
11264 impl CstDecode<crate::error::PaymentError> for wire_cst_payment_error {
11265 fn cst_decode(self) -> crate::error::PaymentError {
11267 match self.tag {
11268 0 => crate::error::PaymentError::AlreadyClaimed,
11269 1 => crate::error::PaymentError::AlreadyPaid,
11270 2 => crate::error::PaymentError::PaymentInProgress,
11271 3 => {
11272 let ans = unsafe { self.kind.AmountOutOfRange };
11273 crate::error::PaymentError::AmountOutOfRange {
11274 min: ans.min.cst_decode(),
11275 max: ans.max.cst_decode(),
11276 }
11277 }
11278 4 => {
11279 let ans = unsafe { self.kind.AmountMissing };
11280 crate::error::PaymentError::AmountMissing {
11281 err: ans.err.cst_decode(),
11282 }
11283 }
11284 5 => {
11285 let ans = unsafe { self.kind.AssetError };
11286 crate::error::PaymentError::AssetError {
11287 err: ans.err.cst_decode(),
11288 }
11289 }
11290 6 => {
11291 let ans = unsafe { self.kind.InvalidNetwork };
11292 crate::error::PaymentError::InvalidNetwork {
11293 err: ans.err.cst_decode(),
11294 }
11295 }
11296 7 => {
11297 let ans = unsafe { self.kind.Generic };
11298 crate::error::PaymentError::Generic {
11299 err: ans.err.cst_decode(),
11300 }
11301 }
11302 8 => crate::error::PaymentError::InvalidOrExpiredFees,
11303 9 => crate::error::PaymentError::InsufficientFunds,
11304 10 => {
11305 let ans = unsafe { self.kind.InvalidDescription };
11306 crate::error::PaymentError::InvalidDescription {
11307 err: ans.err.cst_decode(),
11308 }
11309 }
11310 11 => {
11311 let ans = unsafe { self.kind.InvalidInvoice };
11312 crate::error::PaymentError::InvalidInvoice {
11313 err: ans.err.cst_decode(),
11314 }
11315 }
11316 12 => crate::error::PaymentError::InvalidPreimage,
11317 13 => crate::error::PaymentError::PairsNotFound,
11318 14 => crate::error::PaymentError::PaymentTimeout,
11319 15 => crate::error::PaymentError::PersistError,
11320 16 => {
11321 let ans = unsafe { self.kind.ReceiveError };
11322 crate::error::PaymentError::ReceiveError {
11323 err: ans.err.cst_decode(),
11324 }
11325 }
11326 17 => {
11327 let ans = unsafe { self.kind.Refunded };
11328 crate::error::PaymentError::Refunded {
11329 err: ans.err.cst_decode(),
11330 refund_tx_id: ans.refund_tx_id.cst_decode(),
11331 }
11332 }
11333 18 => crate::error::PaymentError::SelfTransferNotSupported,
11334 19 => {
11335 let ans = unsafe { self.kind.SendError };
11336 crate::error::PaymentError::SendError {
11337 err: ans.err.cst_decode(),
11338 }
11339 }
11340 20 => {
11341 let ans = unsafe { self.kind.SignerError };
11342 crate::error::PaymentError::SignerError {
11343 err: ans.err.cst_decode(),
11344 }
11345 }
11346 _ => unreachable!(),
11347 }
11348 }
11349 }
11350 impl CstDecode<crate::model::PrepareBuyBitcoinRequest> for wire_cst_prepare_buy_bitcoin_request {
11351 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
11353 crate::model::PrepareBuyBitcoinRequest {
11354 provider: self.provider.cst_decode(),
11355 amount_sat: self.amount_sat.cst_decode(),
11356 }
11357 }
11358 }
11359 impl CstDecode<crate::model::PrepareBuyBitcoinResponse> for wire_cst_prepare_buy_bitcoin_response {
11360 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinResponse {
11362 crate::model::PrepareBuyBitcoinResponse {
11363 provider: self.provider.cst_decode(),
11364 amount_sat: self.amount_sat.cst_decode(),
11365 fees_sat: self.fees_sat.cst_decode(),
11366 }
11367 }
11368 }
11369 impl CstDecode<crate::model::PrepareLnUrlPayRequest> for wire_cst_prepare_ln_url_pay_request {
11370 fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
11372 crate::model::PrepareLnUrlPayRequest {
11373 data: self.data.cst_decode(),
11374 amount: self.amount.cst_decode(),
11375 bip353_address: self.bip353_address.cst_decode(),
11376 comment: self.comment.cst_decode(),
11377 validate_success_action_url: self.validate_success_action_url.cst_decode(),
11378 }
11379 }
11380 }
11381 impl CstDecode<crate::model::PrepareLnUrlPayResponse> for wire_cst_prepare_ln_url_pay_response {
11382 fn cst_decode(self) -> crate::model::PrepareLnUrlPayResponse {
11384 crate::model::PrepareLnUrlPayResponse {
11385 destination: self.destination.cst_decode(),
11386 fees_sat: self.fees_sat.cst_decode(),
11387 data: self.data.cst_decode(),
11388 amount: self.amount.cst_decode(),
11389 comment: self.comment.cst_decode(),
11390 success_action: self.success_action.cst_decode(),
11391 }
11392 }
11393 }
11394 impl CstDecode<crate::model::PreparePayOnchainRequest> for wire_cst_prepare_pay_onchain_request {
11395 fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
11397 crate::model::PreparePayOnchainRequest {
11398 amount: self.amount.cst_decode(),
11399 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11400 }
11401 }
11402 }
11403 impl CstDecode<crate::model::PreparePayOnchainResponse> for wire_cst_prepare_pay_onchain_response {
11404 fn cst_decode(self) -> crate::model::PreparePayOnchainResponse {
11406 crate::model::PreparePayOnchainResponse {
11407 receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
11408 claim_fees_sat: self.claim_fees_sat.cst_decode(),
11409 total_fees_sat: self.total_fees_sat.cst_decode(),
11410 }
11411 }
11412 }
11413 impl CstDecode<crate::model::PrepareReceiveRequest> for wire_cst_prepare_receive_request {
11414 fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
11416 crate::model::PrepareReceiveRequest {
11417 payment_method: self.payment_method.cst_decode(),
11418 amount: self.amount.cst_decode(),
11419 }
11420 }
11421 }
11422 impl CstDecode<crate::model::PrepareReceiveResponse> for wire_cst_prepare_receive_response {
11423 fn cst_decode(self) -> crate::model::PrepareReceiveResponse {
11425 crate::model::PrepareReceiveResponse {
11426 payment_method: self.payment_method.cst_decode(),
11427 fees_sat: self.fees_sat.cst_decode(),
11428 amount: self.amount.cst_decode(),
11429 min_payer_amount_sat: self.min_payer_amount_sat.cst_decode(),
11430 max_payer_amount_sat: self.max_payer_amount_sat.cst_decode(),
11431 swapper_feerate: self.swapper_feerate.cst_decode(),
11432 }
11433 }
11434 }
11435 impl CstDecode<crate::model::PrepareRefundRequest> for wire_cst_prepare_refund_request {
11436 fn cst_decode(self) -> crate::model::PrepareRefundRequest {
11438 crate::model::PrepareRefundRequest {
11439 swap_address: self.swap_address.cst_decode(),
11440 refund_address: self.refund_address.cst_decode(),
11441 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11442 }
11443 }
11444 }
11445 impl CstDecode<crate::model::PrepareRefundResponse> for wire_cst_prepare_refund_response {
11446 fn cst_decode(self) -> crate::model::PrepareRefundResponse {
11448 crate::model::PrepareRefundResponse {
11449 tx_vsize: self.tx_vsize.cst_decode(),
11450 tx_fee_sat: self.tx_fee_sat.cst_decode(),
11451 last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11452 }
11453 }
11454 }
11455 impl CstDecode<crate::model::PrepareSendRequest> for wire_cst_prepare_send_request {
11456 fn cst_decode(self) -> crate::model::PrepareSendRequest {
11458 crate::model::PrepareSendRequest {
11459 destination: self.destination.cst_decode(),
11460 amount: self.amount.cst_decode(),
11461 }
11462 }
11463 }
11464 impl CstDecode<crate::model::PrepareSendResponse> for wire_cst_prepare_send_response {
11465 fn cst_decode(self) -> crate::model::PrepareSendResponse {
11467 crate::model::PrepareSendResponse {
11468 destination: self.destination.cst_decode(),
11469 amount: self.amount.cst_decode(),
11470 fees_sat: self.fees_sat.cst_decode(),
11471 estimated_asset_fees: self.estimated_asset_fees.cst_decode(),
11472 exchange_amount_sat: self.exchange_amount_sat.cst_decode(),
11473 }
11474 }
11475 }
11476 impl CstDecode<crate::bindings::Rate> for wire_cst_rate {
11477 fn cst_decode(self) -> crate::bindings::Rate {
11479 crate::bindings::Rate {
11480 coin: self.coin.cst_decode(),
11481 value: self.value.cst_decode(),
11482 }
11483 }
11484 }
11485 impl CstDecode<crate::model::ReceiveAmount> for wire_cst_receive_amount {
11486 fn cst_decode(self) -> crate::model::ReceiveAmount {
11488 match self.tag {
11489 0 => {
11490 let ans = unsafe { self.kind.Bitcoin };
11491 crate::model::ReceiveAmount::Bitcoin {
11492 payer_amount_sat: ans.payer_amount_sat.cst_decode(),
11493 }
11494 }
11495 1 => {
11496 let ans = unsafe { self.kind.Asset };
11497 crate::model::ReceiveAmount::Asset {
11498 asset_id: ans.asset_id.cst_decode(),
11499 payer_amount: ans.payer_amount.cst_decode(),
11500 }
11501 }
11502 _ => unreachable!(),
11503 }
11504 }
11505 }
11506 impl CstDecode<crate::model::ReceivePaymentRequest> for wire_cst_receive_payment_request {
11507 fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
11509 crate::model::ReceivePaymentRequest {
11510 prepare_response: self.prepare_response.cst_decode(),
11511 description: self.description.cst_decode(),
11512 use_description_hash: self.use_description_hash.cst_decode(),
11513 payer_note: self.payer_note.cst_decode(),
11514 }
11515 }
11516 }
11517 impl CstDecode<crate::model::ReceivePaymentResponse> for wire_cst_receive_payment_response {
11518 fn cst_decode(self) -> crate::model::ReceivePaymentResponse {
11520 crate::model::ReceivePaymentResponse {
11521 destination: self.destination.cst_decode(),
11522 liquid_expiration_blockheight: self.liquid_expiration_blockheight.cst_decode(),
11523 bitcoin_expiration_blockheight: self.bitcoin_expiration_blockheight.cst_decode(),
11524 }
11525 }
11526 }
11527 impl CstDecode<crate::model::RecommendedFees> for wire_cst_recommended_fees {
11528 fn cst_decode(self) -> crate::model::RecommendedFees {
11530 crate::model::RecommendedFees {
11531 fastest_fee: self.fastest_fee.cst_decode(),
11532 half_hour_fee: self.half_hour_fee.cst_decode(),
11533 hour_fee: self.hour_fee.cst_decode(),
11534 economy_fee: self.economy_fee.cst_decode(),
11535 minimum_fee: self.minimum_fee.cst_decode(),
11536 }
11537 }
11538 }
11539 impl CstDecode<crate::model::RefundRequest> for wire_cst_refund_request {
11540 fn cst_decode(self) -> crate::model::RefundRequest {
11542 crate::model::RefundRequest {
11543 swap_address: self.swap_address.cst_decode(),
11544 refund_address: self.refund_address.cst_decode(),
11545 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11546 }
11547 }
11548 }
11549 impl CstDecode<crate::model::RefundResponse> for wire_cst_refund_response {
11550 fn cst_decode(self) -> crate::model::RefundResponse {
11552 crate::model::RefundResponse {
11553 refund_tx_id: self.refund_tx_id.cst_decode(),
11554 }
11555 }
11556 }
11557 impl CstDecode<crate::model::RefundableSwap> for wire_cst_refundable_swap {
11558 fn cst_decode(self) -> crate::model::RefundableSwap {
11560 crate::model::RefundableSwap {
11561 swap_address: self.swap_address.cst_decode(),
11562 timestamp: self.timestamp.cst_decode(),
11563 amount_sat: self.amount_sat.cst_decode(),
11564 last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11565 }
11566 }
11567 }
11568 impl CstDecode<crate::model::RestoreRequest> for wire_cst_restore_request {
11569 fn cst_decode(self) -> crate::model::RestoreRequest {
11571 crate::model::RestoreRequest {
11572 backup_path: self.backup_path.cst_decode(),
11573 }
11574 }
11575 }
11576 impl CstDecode<crate::bindings::RouteHint> for wire_cst_route_hint {
11577 fn cst_decode(self) -> crate::bindings::RouteHint {
11579 crate::bindings::RouteHint {
11580 hops: self.hops.cst_decode(),
11581 }
11582 }
11583 }
11584 impl CstDecode<crate::bindings::RouteHintHop> for wire_cst_route_hint_hop {
11585 fn cst_decode(self) -> crate::bindings::RouteHintHop {
11587 crate::bindings::RouteHintHop {
11588 src_node_id: self.src_node_id.cst_decode(),
11589 short_channel_id: self.short_channel_id.cst_decode(),
11590 fees_base_msat: self.fees_base_msat.cst_decode(),
11591 fees_proportional_millionths: self.fees_proportional_millionths.cst_decode(),
11592 cltv_expiry_delta: self.cltv_expiry_delta.cst_decode(),
11593 htlc_minimum_msat: self.htlc_minimum_msat.cst_decode(),
11594 htlc_maximum_msat: self.htlc_maximum_msat.cst_decode(),
11595 }
11596 }
11597 }
11598 impl CstDecode<crate::error::SdkError> for wire_cst_sdk_error {
11599 fn cst_decode(self) -> crate::error::SdkError {
11601 match self.tag {
11602 0 => crate::error::SdkError::AlreadyStarted,
11603 1 => {
11604 let ans = unsafe { self.kind.Generic };
11605 crate::error::SdkError::Generic {
11606 err: ans.err.cst_decode(),
11607 }
11608 }
11609 2 => crate::error::SdkError::NotStarted,
11610 3 => {
11611 let ans = unsafe { self.kind.ServiceConnectivity };
11612 crate::error::SdkError::ServiceConnectivity {
11613 err: ans.err.cst_decode(),
11614 }
11615 }
11616 _ => unreachable!(),
11617 }
11618 }
11619 }
11620 impl CstDecode<crate::model::SdkEvent> for wire_cst_sdk_event {
11621 fn cst_decode(self) -> crate::model::SdkEvent {
11623 match self.tag {
11624 0 => {
11625 let ans = unsafe { self.kind.PaymentFailed };
11626 crate::model::SdkEvent::PaymentFailed {
11627 details: ans.details.cst_decode(),
11628 }
11629 }
11630 1 => {
11631 let ans = unsafe { self.kind.PaymentPending };
11632 crate::model::SdkEvent::PaymentPending {
11633 details: ans.details.cst_decode(),
11634 }
11635 }
11636 2 => {
11637 let ans = unsafe { self.kind.PaymentRefundable };
11638 crate::model::SdkEvent::PaymentRefundable {
11639 details: ans.details.cst_decode(),
11640 }
11641 }
11642 3 => {
11643 let ans = unsafe { self.kind.PaymentRefunded };
11644 crate::model::SdkEvent::PaymentRefunded {
11645 details: ans.details.cst_decode(),
11646 }
11647 }
11648 4 => {
11649 let ans = unsafe { self.kind.PaymentRefundPending };
11650 crate::model::SdkEvent::PaymentRefundPending {
11651 details: ans.details.cst_decode(),
11652 }
11653 }
11654 5 => {
11655 let ans = unsafe { self.kind.PaymentSucceeded };
11656 crate::model::SdkEvent::PaymentSucceeded {
11657 details: ans.details.cst_decode(),
11658 }
11659 }
11660 6 => {
11661 let ans = unsafe { self.kind.PaymentWaitingConfirmation };
11662 crate::model::SdkEvent::PaymentWaitingConfirmation {
11663 details: ans.details.cst_decode(),
11664 }
11665 }
11666 7 => {
11667 let ans = unsafe { self.kind.PaymentWaitingFeeAcceptance };
11668 crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
11669 details: ans.details.cst_decode(),
11670 }
11671 }
11672 8 => crate::model::SdkEvent::Synced,
11673 9 => {
11674 let ans = unsafe { self.kind.DataSynced };
11675 crate::model::SdkEvent::DataSynced {
11676 did_pull_new_records: ans.did_pull_new_records.cst_decode(),
11677 }
11678 }
11679 _ => unreachable!(),
11680 }
11681 }
11682 }
11683 impl CstDecode<crate::model::SendDestination> for wire_cst_send_destination {
11684 fn cst_decode(self) -> crate::model::SendDestination {
11686 match self.tag {
11687 0 => {
11688 let ans = unsafe { self.kind.LiquidAddress };
11689 crate::model::SendDestination::LiquidAddress {
11690 address_data: ans.address_data.cst_decode(),
11691 bip353_address: ans.bip353_address.cst_decode(),
11692 }
11693 }
11694 1 => {
11695 let ans = unsafe { self.kind.Bolt11 };
11696 crate::model::SendDestination::Bolt11 {
11697 invoice: ans.invoice.cst_decode(),
11698 bip353_address: ans.bip353_address.cst_decode(),
11699 }
11700 }
11701 2 => {
11702 let ans = unsafe { self.kind.Bolt12 };
11703 crate::model::SendDestination::Bolt12 {
11704 offer: ans.offer.cst_decode(),
11705 receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11706 bip353_address: ans.bip353_address.cst_decode(),
11707 }
11708 }
11709 _ => unreachable!(),
11710 }
11711 }
11712 }
11713 impl CstDecode<crate::model::SendPaymentRequest> for wire_cst_send_payment_request {
11714 fn cst_decode(self) -> crate::model::SendPaymentRequest {
11716 crate::model::SendPaymentRequest {
11717 prepare_response: self.prepare_response.cst_decode(),
11718 use_asset_fees: self.use_asset_fees.cst_decode(),
11719 payer_note: self.payer_note.cst_decode(),
11720 }
11721 }
11722 }
11723 impl CstDecode<crate::model::SendPaymentResponse> for wire_cst_send_payment_response {
11724 fn cst_decode(self) -> crate::model::SendPaymentResponse {
11726 crate::model::SendPaymentResponse {
11727 payment: self.payment.cst_decode(),
11728 }
11729 }
11730 }
11731 impl CstDecode<crate::model::SignMessageRequest> for wire_cst_sign_message_request {
11732 fn cst_decode(self) -> crate::model::SignMessageRequest {
11734 crate::model::SignMessageRequest {
11735 message: self.message.cst_decode(),
11736 }
11737 }
11738 }
11739 impl CstDecode<crate::model::SignMessageResponse> for wire_cst_sign_message_response {
11740 fn cst_decode(self) -> crate::model::SignMessageResponse {
11742 crate::model::SignMessageResponse {
11743 signature: self.signature.cst_decode(),
11744 }
11745 }
11746 }
11747 impl CstDecode<crate::bindings::SuccessAction> for wire_cst_success_action {
11748 fn cst_decode(self) -> crate::bindings::SuccessAction {
11750 match self.tag {
11751 0 => {
11752 let ans = unsafe { self.kind.Aes };
11753 crate::bindings::SuccessAction::Aes {
11754 data: ans.data.cst_decode(),
11755 }
11756 }
11757 1 => {
11758 let ans = unsafe { self.kind.Message };
11759 crate::bindings::SuccessAction::Message {
11760 data: ans.data.cst_decode(),
11761 }
11762 }
11763 2 => {
11764 let ans = unsafe { self.kind.Url };
11765 crate::bindings::SuccessAction::Url {
11766 data: ans.data.cst_decode(),
11767 }
11768 }
11769 _ => unreachable!(),
11770 }
11771 }
11772 }
11773 impl CstDecode<crate::bindings::SuccessActionProcessed> for wire_cst_success_action_processed {
11774 fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
11776 match self.tag {
11777 0 => {
11778 let ans = unsafe { self.kind.Aes };
11779 crate::bindings::SuccessActionProcessed::Aes {
11780 result: ans.result.cst_decode(),
11781 }
11782 }
11783 1 => {
11784 let ans = unsafe { self.kind.Message };
11785 crate::bindings::SuccessActionProcessed::Message {
11786 data: ans.data.cst_decode(),
11787 }
11788 }
11789 2 => {
11790 let ans = unsafe { self.kind.Url };
11791 crate::bindings::SuccessActionProcessed::Url {
11792 data: ans.data.cst_decode(),
11793 }
11794 }
11795 _ => unreachable!(),
11796 }
11797 }
11798 }
11799 impl CstDecode<crate::bindings::Symbol> for wire_cst_symbol {
11800 fn cst_decode(self) -> crate::bindings::Symbol {
11802 crate::bindings::Symbol {
11803 grapheme: self.grapheme.cst_decode(),
11804 template: self.template.cst_decode(),
11805 rtl: self.rtl.cst_decode(),
11806 position: self.position.cst_decode(),
11807 }
11808 }
11809 }
11810 impl CstDecode<crate::bindings::UrlSuccessActionData> for wire_cst_url_success_action_data {
11811 fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
11813 crate::bindings::UrlSuccessActionData {
11814 description: self.description.cst_decode(),
11815 url: self.url.cst_decode(),
11816 matches_callback_domain: self.matches_callback_domain.cst_decode(),
11817 }
11818 }
11819 }
11820 impl CstDecode<crate::model::WalletInfo> for wire_cst_wallet_info {
11821 fn cst_decode(self) -> crate::model::WalletInfo {
11823 crate::model::WalletInfo {
11824 balance_sat: self.balance_sat.cst_decode(),
11825 pending_send_sat: self.pending_send_sat.cst_decode(),
11826 pending_receive_sat: self.pending_receive_sat.cst_decode(),
11827 fingerprint: self.fingerprint.cst_decode(),
11828 pubkey: self.pubkey.cst_decode(),
11829 asset_balances: self.asset_balances.cst_decode(),
11830 }
11831 }
11832 }
11833 impl NewWithNullPtr for wire_cst_accept_payment_proposed_fees_request {
11834 fn new_with_null_ptr() -> Self {
11835 Self {
11836 response: Default::default(),
11837 }
11838 }
11839 }
11840 impl Default for wire_cst_accept_payment_proposed_fees_request {
11841 fn default() -> Self {
11842 Self::new_with_null_ptr()
11843 }
11844 }
11845 impl NewWithNullPtr for wire_cst_aes_success_action_data {
11846 fn new_with_null_ptr() -> Self {
11847 Self {
11848 description: core::ptr::null_mut(),
11849 ciphertext: core::ptr::null_mut(),
11850 iv: core::ptr::null_mut(),
11851 }
11852 }
11853 }
11854 impl Default for wire_cst_aes_success_action_data {
11855 fn default() -> Self {
11856 Self::new_with_null_ptr()
11857 }
11858 }
11859 impl NewWithNullPtr for wire_cst_aes_success_action_data_decrypted {
11860 fn new_with_null_ptr() -> Self {
11861 Self {
11862 description: core::ptr::null_mut(),
11863 plaintext: core::ptr::null_mut(),
11864 }
11865 }
11866 }
11867 impl Default for wire_cst_aes_success_action_data_decrypted {
11868 fn default() -> Self {
11869 Self::new_with_null_ptr()
11870 }
11871 }
11872 impl NewWithNullPtr for wire_cst_aes_success_action_data_result {
11873 fn new_with_null_ptr() -> Self {
11874 Self {
11875 tag: -1,
11876 kind: AesSuccessActionDataResultKind { nil__: () },
11877 }
11878 }
11879 }
11880 impl Default for wire_cst_aes_success_action_data_result {
11881 fn default() -> Self {
11882 Self::new_with_null_ptr()
11883 }
11884 }
11885 impl NewWithNullPtr for wire_cst_amount {
11886 fn new_with_null_ptr() -> Self {
11887 Self {
11888 tag: -1,
11889 kind: AmountKind { nil__: () },
11890 }
11891 }
11892 }
11893 impl Default for wire_cst_amount {
11894 fn default() -> Self {
11895 Self::new_with_null_ptr()
11896 }
11897 }
11898 impl NewWithNullPtr for wire_cst_asset_balance {
11899 fn new_with_null_ptr() -> Self {
11900 Self {
11901 asset_id: core::ptr::null_mut(),
11902 balance_sat: Default::default(),
11903 name: core::ptr::null_mut(),
11904 ticker: core::ptr::null_mut(),
11905 balance: core::ptr::null_mut(),
11906 }
11907 }
11908 }
11909 impl Default for wire_cst_asset_balance {
11910 fn default() -> Self {
11911 Self::new_with_null_ptr()
11912 }
11913 }
11914 impl NewWithNullPtr for wire_cst_asset_info {
11915 fn new_with_null_ptr() -> Self {
11916 Self {
11917 name: core::ptr::null_mut(),
11918 ticker: core::ptr::null_mut(),
11919 amount: Default::default(),
11920 fees: core::ptr::null_mut(),
11921 }
11922 }
11923 }
11924 impl Default for wire_cst_asset_info {
11925 fn default() -> Self {
11926 Self::new_with_null_ptr()
11927 }
11928 }
11929 impl NewWithNullPtr for wire_cst_asset_metadata {
11930 fn new_with_null_ptr() -> Self {
11931 Self {
11932 asset_id: core::ptr::null_mut(),
11933 name: core::ptr::null_mut(),
11934 ticker: core::ptr::null_mut(),
11935 precision: Default::default(),
11936 fiat_id: core::ptr::null_mut(),
11937 }
11938 }
11939 }
11940 impl Default for wire_cst_asset_metadata {
11941 fn default() -> Self {
11942 Self::new_with_null_ptr()
11943 }
11944 }
11945 impl NewWithNullPtr for wire_cst_backup_request {
11946 fn new_with_null_ptr() -> Self {
11947 Self {
11948 backup_path: core::ptr::null_mut(),
11949 }
11950 }
11951 }
11952 impl Default for wire_cst_backup_request {
11953 fn default() -> Self {
11954 Self::new_with_null_ptr()
11955 }
11956 }
11957 impl NewWithNullPtr for wire_cst_binding_event_listener {
11958 fn new_with_null_ptr() -> Self {
11959 Self {
11960 stream: core::ptr::null_mut(),
11961 }
11962 }
11963 }
11964 impl Default for wire_cst_binding_event_listener {
11965 fn default() -> Self {
11966 Self::new_with_null_ptr()
11967 }
11968 }
11969 impl NewWithNullPtr for wire_cst_bitcoin_address_data {
11970 fn new_with_null_ptr() -> Self {
11971 Self {
11972 address: core::ptr::null_mut(),
11973 network: Default::default(),
11974 amount_sat: core::ptr::null_mut(),
11975 label: core::ptr::null_mut(),
11976 message: core::ptr::null_mut(),
11977 }
11978 }
11979 }
11980 impl Default for wire_cst_bitcoin_address_data {
11981 fn default() -> Self {
11982 Self::new_with_null_ptr()
11983 }
11984 }
11985 impl NewWithNullPtr for wire_cst_blockchain_explorer {
11986 fn new_with_null_ptr() -> Self {
11987 Self {
11988 tag: -1,
11989 kind: BlockchainExplorerKind { nil__: () },
11990 }
11991 }
11992 }
11993 impl Default for wire_cst_blockchain_explorer {
11994 fn default() -> Self {
11995 Self::new_with_null_ptr()
11996 }
11997 }
11998 impl NewWithNullPtr for wire_cst_blockchain_info {
11999 fn new_with_null_ptr() -> Self {
12000 Self {
12001 liquid_tip: Default::default(),
12002 bitcoin_tip: Default::default(),
12003 }
12004 }
12005 }
12006 impl Default for wire_cst_blockchain_info {
12007 fn default() -> Self {
12008 Self::new_with_null_ptr()
12009 }
12010 }
12011 impl NewWithNullPtr for wire_cst_buy_bitcoin_request {
12012 fn new_with_null_ptr() -> Self {
12013 Self {
12014 prepare_response: Default::default(),
12015 redirect_url: core::ptr::null_mut(),
12016 }
12017 }
12018 }
12019 impl Default for wire_cst_buy_bitcoin_request {
12020 fn default() -> Self {
12021 Self::new_with_null_ptr()
12022 }
12023 }
12024 impl NewWithNullPtr for wire_cst_check_message_request {
12025 fn new_with_null_ptr() -> Self {
12026 Self {
12027 message: core::ptr::null_mut(),
12028 pubkey: core::ptr::null_mut(),
12029 signature: core::ptr::null_mut(),
12030 }
12031 }
12032 }
12033 impl Default for wire_cst_check_message_request {
12034 fn default() -> Self {
12035 Self::new_with_null_ptr()
12036 }
12037 }
12038 impl NewWithNullPtr for wire_cst_check_message_response {
12039 fn new_with_null_ptr() -> Self {
12040 Self {
12041 is_valid: Default::default(),
12042 }
12043 }
12044 }
12045 impl Default for wire_cst_check_message_response {
12046 fn default() -> Self {
12047 Self::new_with_null_ptr()
12048 }
12049 }
12050 impl NewWithNullPtr for wire_cst_config {
12051 fn new_with_null_ptr() -> Self {
12052 Self {
12053 liquid_explorer: Default::default(),
12054 bitcoin_explorer: Default::default(),
12055 working_dir: core::ptr::null_mut(),
12056 network: Default::default(),
12057 payment_timeout_sec: Default::default(),
12058 sync_service_url: core::ptr::null_mut(),
12059 zero_conf_max_amount_sat: core::ptr::null_mut(),
12060 breez_api_key: core::ptr::null_mut(),
12061 external_input_parsers: core::ptr::null_mut(),
12062 use_default_external_input_parsers: Default::default(),
12063 onchain_fee_rate_leeway_sat: core::ptr::null_mut(),
12064 asset_metadata: core::ptr::null_mut(),
12065 sideswap_api_key: core::ptr::null_mut(),
12066 use_magic_routing_hints: Default::default(),
12067 }
12068 }
12069 }
12070 impl Default for wire_cst_config {
12071 fn default() -> Self {
12072 Self::new_with_null_ptr()
12073 }
12074 }
12075 impl NewWithNullPtr for wire_cst_connect_request {
12076 fn new_with_null_ptr() -> Self {
12077 Self {
12078 config: Default::default(),
12079 mnemonic: core::ptr::null_mut(),
12080 passphrase: core::ptr::null_mut(),
12081 seed: core::ptr::null_mut(),
12082 }
12083 }
12084 }
12085 impl Default for wire_cst_connect_request {
12086 fn default() -> Self {
12087 Self::new_with_null_ptr()
12088 }
12089 }
12090 impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_request {
12091 fn new_with_null_ptr() -> Self {
12092 Self {
12093 offer: core::ptr::null_mut(),
12094 invoice_request: core::ptr::null_mut(),
12095 }
12096 }
12097 }
12098 impl Default for wire_cst_create_bolt_12_invoice_request {
12099 fn default() -> Self {
12100 Self::new_with_null_ptr()
12101 }
12102 }
12103 impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_response {
12104 fn new_with_null_ptr() -> Self {
12105 Self {
12106 invoice: core::ptr::null_mut(),
12107 }
12108 }
12109 }
12110 impl Default for wire_cst_create_bolt_12_invoice_response {
12111 fn default() -> Self {
12112 Self::new_with_null_ptr()
12113 }
12114 }
12115 impl NewWithNullPtr for wire_cst_currency_info {
12116 fn new_with_null_ptr() -> Self {
12117 Self {
12118 name: core::ptr::null_mut(),
12119 fraction_size: Default::default(),
12120 spacing: core::ptr::null_mut(),
12121 symbol: core::ptr::null_mut(),
12122 uniq_symbol: core::ptr::null_mut(),
12123 localized_name: core::ptr::null_mut(),
12124 locale_overrides: core::ptr::null_mut(),
12125 }
12126 }
12127 }
12128 impl Default for wire_cst_currency_info {
12129 fn default() -> Self {
12130 Self::new_with_null_ptr()
12131 }
12132 }
12133 impl NewWithNullPtr for wire_cst_external_input_parser {
12134 fn new_with_null_ptr() -> Self {
12135 Self {
12136 provider_id: core::ptr::null_mut(),
12137 input_regex: core::ptr::null_mut(),
12138 parser_url: core::ptr::null_mut(),
12139 }
12140 }
12141 }
12142 impl Default for wire_cst_external_input_parser {
12143 fn default() -> Self {
12144 Self::new_with_null_ptr()
12145 }
12146 }
12147 impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_request {
12148 fn new_with_null_ptr() -> Self {
12149 Self {
12150 swap_id: core::ptr::null_mut(),
12151 }
12152 }
12153 }
12154 impl Default for wire_cst_fetch_payment_proposed_fees_request {
12155 fn default() -> Self {
12156 Self::new_with_null_ptr()
12157 }
12158 }
12159 impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_response {
12160 fn new_with_null_ptr() -> Self {
12161 Self {
12162 swap_id: core::ptr::null_mut(),
12163 fees_sat: Default::default(),
12164 payer_amount_sat: Default::default(),
12165 receiver_amount_sat: Default::default(),
12166 }
12167 }
12168 }
12169 impl Default for wire_cst_fetch_payment_proposed_fees_response {
12170 fn default() -> Self {
12171 Self::new_with_null_ptr()
12172 }
12173 }
12174 impl NewWithNullPtr for wire_cst_fiat_currency {
12175 fn new_with_null_ptr() -> Self {
12176 Self {
12177 id: core::ptr::null_mut(),
12178 info: Default::default(),
12179 }
12180 }
12181 }
12182 impl Default for wire_cst_fiat_currency {
12183 fn default() -> Self {
12184 Self::new_with_null_ptr()
12185 }
12186 }
12187 impl NewWithNullPtr for wire_cst_get_info_response {
12188 fn new_with_null_ptr() -> Self {
12189 Self {
12190 wallet_info: Default::default(),
12191 blockchain_info: Default::default(),
12192 }
12193 }
12194 }
12195 impl Default for wire_cst_get_info_response {
12196 fn default() -> Self {
12197 Self::new_with_null_ptr()
12198 }
12199 }
12200 impl NewWithNullPtr for wire_cst_get_payment_request {
12201 fn new_with_null_ptr() -> Self {
12202 Self {
12203 tag: -1,
12204 kind: GetPaymentRequestKind { nil__: () },
12205 }
12206 }
12207 }
12208 impl Default for wire_cst_get_payment_request {
12209 fn default() -> Self {
12210 Self::new_with_null_ptr()
12211 }
12212 }
12213 impl NewWithNullPtr for wire_cst_input_type {
12214 fn new_with_null_ptr() -> Self {
12215 Self {
12216 tag: -1,
12217 kind: InputTypeKind { nil__: () },
12218 }
12219 }
12220 }
12221 impl Default for wire_cst_input_type {
12222 fn default() -> Self {
12223 Self::new_with_null_ptr()
12224 }
12225 }
12226 impl NewWithNullPtr for wire_cst_lightning_payment_limits_response {
12227 fn new_with_null_ptr() -> Self {
12228 Self {
12229 send: Default::default(),
12230 receive: Default::default(),
12231 }
12232 }
12233 }
12234 impl Default for wire_cst_lightning_payment_limits_response {
12235 fn default() -> Self {
12236 Self::new_with_null_ptr()
12237 }
12238 }
12239 impl NewWithNullPtr for wire_cst_limits {
12240 fn new_with_null_ptr() -> Self {
12241 Self {
12242 min_sat: Default::default(),
12243 max_sat: Default::default(),
12244 max_zero_conf_sat: Default::default(),
12245 }
12246 }
12247 }
12248 impl Default for wire_cst_limits {
12249 fn default() -> Self {
12250 Self::new_with_null_ptr()
12251 }
12252 }
12253 impl NewWithNullPtr for wire_cst_liquid_address_data {
12254 fn new_with_null_ptr() -> Self {
12255 Self {
12256 address: core::ptr::null_mut(),
12257 network: Default::default(),
12258 asset_id: core::ptr::null_mut(),
12259 amount: core::ptr::null_mut(),
12260 amount_sat: core::ptr::null_mut(),
12261 label: core::ptr::null_mut(),
12262 message: core::ptr::null_mut(),
12263 }
12264 }
12265 }
12266 impl Default for wire_cst_liquid_address_data {
12267 fn default() -> Self {
12268 Self::new_with_null_ptr()
12269 }
12270 }
12271 impl NewWithNullPtr for wire_cst_list_payment_details {
12272 fn new_with_null_ptr() -> Self {
12273 Self {
12274 tag: -1,
12275 kind: ListPaymentDetailsKind { nil__: () },
12276 }
12277 }
12278 }
12279 impl Default for wire_cst_list_payment_details {
12280 fn default() -> Self {
12281 Self::new_with_null_ptr()
12282 }
12283 }
12284 impl NewWithNullPtr for wire_cst_list_payments_request {
12285 fn new_with_null_ptr() -> Self {
12286 Self {
12287 filters: core::ptr::null_mut(),
12288 states: core::ptr::null_mut(),
12289 from_timestamp: core::ptr::null_mut(),
12290 to_timestamp: core::ptr::null_mut(),
12291 offset: core::ptr::null_mut(),
12292 limit: core::ptr::null_mut(),
12293 details: core::ptr::null_mut(),
12294 sort_ascending: core::ptr::null_mut(),
12295 }
12296 }
12297 }
12298 impl Default for wire_cst_list_payments_request {
12299 fn default() -> Self {
12300 Self::new_with_null_ptr()
12301 }
12302 }
12303 impl NewWithNullPtr for wire_cst_ln_invoice {
12304 fn new_with_null_ptr() -> Self {
12305 Self {
12306 bolt11: core::ptr::null_mut(),
12307 network: Default::default(),
12308 payee_pubkey: core::ptr::null_mut(),
12309 payment_hash: core::ptr::null_mut(),
12310 description: core::ptr::null_mut(),
12311 description_hash: core::ptr::null_mut(),
12312 amount_msat: core::ptr::null_mut(),
12313 timestamp: Default::default(),
12314 expiry: Default::default(),
12315 routing_hints: core::ptr::null_mut(),
12316 payment_secret: core::ptr::null_mut(),
12317 min_final_cltv_expiry_delta: Default::default(),
12318 }
12319 }
12320 }
12321 impl Default for wire_cst_ln_invoice {
12322 fn default() -> Self {
12323 Self::new_with_null_ptr()
12324 }
12325 }
12326 impl NewWithNullPtr for wire_cst_ln_offer {
12327 fn new_with_null_ptr() -> Self {
12328 Self {
12329 offer: core::ptr::null_mut(),
12330 chains: core::ptr::null_mut(),
12331 min_amount: core::ptr::null_mut(),
12332 description: core::ptr::null_mut(),
12333 absolute_expiry: core::ptr::null_mut(),
12334 issuer: core::ptr::null_mut(),
12335 signing_pubkey: core::ptr::null_mut(),
12336 paths: core::ptr::null_mut(),
12337 }
12338 }
12339 }
12340 impl Default for wire_cst_ln_offer {
12341 fn default() -> Self {
12342 Self::new_with_null_ptr()
12343 }
12344 }
12345 impl NewWithNullPtr for wire_cst_ln_offer_blinded_path {
12346 fn new_with_null_ptr() -> Self {
12347 Self {
12348 blinded_hops: core::ptr::null_mut(),
12349 }
12350 }
12351 }
12352 impl Default for wire_cst_ln_offer_blinded_path {
12353 fn default() -> Self {
12354 Self::new_with_null_ptr()
12355 }
12356 }
12357 impl NewWithNullPtr for wire_cst_ln_url_auth_error {
12358 fn new_with_null_ptr() -> Self {
12359 Self {
12360 tag: -1,
12361 kind: LnUrlAuthErrorKind { nil__: () },
12362 }
12363 }
12364 }
12365 impl Default for wire_cst_ln_url_auth_error {
12366 fn default() -> Self {
12367 Self::new_with_null_ptr()
12368 }
12369 }
12370 impl NewWithNullPtr for wire_cst_ln_url_auth_request_data {
12371 fn new_with_null_ptr() -> Self {
12372 Self {
12373 k1: core::ptr::null_mut(),
12374 action: core::ptr::null_mut(),
12375 domain: core::ptr::null_mut(),
12376 url: core::ptr::null_mut(),
12377 }
12378 }
12379 }
12380 impl Default for wire_cst_ln_url_auth_request_data {
12381 fn default() -> Self {
12382 Self::new_with_null_ptr()
12383 }
12384 }
12385 impl NewWithNullPtr for wire_cst_ln_url_callback_status {
12386 fn new_with_null_ptr() -> Self {
12387 Self {
12388 tag: -1,
12389 kind: LnUrlCallbackStatusKind { nil__: () },
12390 }
12391 }
12392 }
12393 impl Default for wire_cst_ln_url_callback_status {
12394 fn default() -> Self {
12395 Self::new_with_null_ptr()
12396 }
12397 }
12398 impl NewWithNullPtr for wire_cst_ln_url_error_data {
12399 fn new_with_null_ptr() -> Self {
12400 Self {
12401 reason: core::ptr::null_mut(),
12402 }
12403 }
12404 }
12405 impl Default for wire_cst_ln_url_error_data {
12406 fn default() -> Self {
12407 Self::new_with_null_ptr()
12408 }
12409 }
12410 impl NewWithNullPtr for wire_cst_ln_url_info {
12411 fn new_with_null_ptr() -> Self {
12412 Self {
12413 ln_address: core::ptr::null_mut(),
12414 lnurl_pay_comment: core::ptr::null_mut(),
12415 lnurl_pay_domain: core::ptr::null_mut(),
12416 lnurl_pay_metadata: core::ptr::null_mut(),
12417 lnurl_pay_success_action: core::ptr::null_mut(),
12418 lnurl_pay_unprocessed_success_action: core::ptr::null_mut(),
12419 lnurl_withdraw_endpoint: core::ptr::null_mut(),
12420 }
12421 }
12422 }
12423 impl Default for wire_cst_ln_url_info {
12424 fn default() -> Self {
12425 Self::new_with_null_ptr()
12426 }
12427 }
12428 impl NewWithNullPtr for wire_cst_ln_url_pay_error {
12429 fn new_with_null_ptr() -> Self {
12430 Self {
12431 tag: -1,
12432 kind: LnUrlPayErrorKind { nil__: () },
12433 }
12434 }
12435 }
12436 impl Default for wire_cst_ln_url_pay_error {
12437 fn default() -> Self {
12438 Self::new_with_null_ptr()
12439 }
12440 }
12441 impl NewWithNullPtr for wire_cst_ln_url_pay_error_data {
12442 fn new_with_null_ptr() -> Self {
12443 Self {
12444 payment_hash: core::ptr::null_mut(),
12445 reason: core::ptr::null_mut(),
12446 }
12447 }
12448 }
12449 impl Default for wire_cst_ln_url_pay_error_data {
12450 fn default() -> Self {
12451 Self::new_with_null_ptr()
12452 }
12453 }
12454 impl NewWithNullPtr for wire_cst_ln_url_pay_request {
12455 fn new_with_null_ptr() -> Self {
12456 Self {
12457 prepare_response: Default::default(),
12458 }
12459 }
12460 }
12461 impl Default for wire_cst_ln_url_pay_request {
12462 fn default() -> Self {
12463 Self::new_with_null_ptr()
12464 }
12465 }
12466 impl NewWithNullPtr for wire_cst_ln_url_pay_request_data {
12467 fn new_with_null_ptr() -> Self {
12468 Self {
12469 callback: core::ptr::null_mut(),
12470 min_sendable: Default::default(),
12471 max_sendable: Default::default(),
12472 metadata_str: core::ptr::null_mut(),
12473 comment_allowed: Default::default(),
12474 domain: core::ptr::null_mut(),
12475 allows_nostr: Default::default(),
12476 nostr_pubkey: core::ptr::null_mut(),
12477 ln_address: core::ptr::null_mut(),
12478 }
12479 }
12480 }
12481 impl Default for wire_cst_ln_url_pay_request_data {
12482 fn default() -> Self {
12483 Self::new_with_null_ptr()
12484 }
12485 }
12486 impl NewWithNullPtr for wire_cst_ln_url_pay_result {
12487 fn new_with_null_ptr() -> Self {
12488 Self {
12489 tag: -1,
12490 kind: LnUrlPayResultKind { nil__: () },
12491 }
12492 }
12493 }
12494 impl Default for wire_cst_ln_url_pay_result {
12495 fn default() -> Self {
12496 Self::new_with_null_ptr()
12497 }
12498 }
12499 impl NewWithNullPtr for wire_cst_ln_url_pay_success_data {
12500 fn new_with_null_ptr() -> Self {
12501 Self {
12502 payment: Default::default(),
12503 success_action: core::ptr::null_mut(),
12504 }
12505 }
12506 }
12507 impl Default for wire_cst_ln_url_pay_success_data {
12508 fn default() -> Self {
12509 Self::new_with_null_ptr()
12510 }
12511 }
12512 impl NewWithNullPtr for wire_cst_ln_url_withdraw_error {
12513 fn new_with_null_ptr() -> Self {
12514 Self {
12515 tag: -1,
12516 kind: LnUrlWithdrawErrorKind { nil__: () },
12517 }
12518 }
12519 }
12520 impl Default for wire_cst_ln_url_withdraw_error {
12521 fn default() -> Self {
12522 Self::new_with_null_ptr()
12523 }
12524 }
12525 impl NewWithNullPtr for wire_cst_ln_url_withdraw_request {
12526 fn new_with_null_ptr() -> Self {
12527 Self {
12528 data: Default::default(),
12529 amount_msat: Default::default(),
12530 description: core::ptr::null_mut(),
12531 }
12532 }
12533 }
12534 impl Default for wire_cst_ln_url_withdraw_request {
12535 fn default() -> Self {
12536 Self::new_with_null_ptr()
12537 }
12538 }
12539 impl NewWithNullPtr for wire_cst_ln_url_withdraw_request_data {
12540 fn new_with_null_ptr() -> Self {
12541 Self {
12542 callback: core::ptr::null_mut(),
12543 k1: core::ptr::null_mut(),
12544 default_description: core::ptr::null_mut(),
12545 min_withdrawable: Default::default(),
12546 max_withdrawable: Default::default(),
12547 }
12548 }
12549 }
12550 impl Default for wire_cst_ln_url_withdraw_request_data {
12551 fn default() -> Self {
12552 Self::new_with_null_ptr()
12553 }
12554 }
12555 impl NewWithNullPtr for wire_cst_ln_url_withdraw_result {
12556 fn new_with_null_ptr() -> Self {
12557 Self {
12558 tag: -1,
12559 kind: LnUrlWithdrawResultKind { nil__: () },
12560 }
12561 }
12562 }
12563 impl Default for wire_cst_ln_url_withdraw_result {
12564 fn default() -> Self {
12565 Self::new_with_null_ptr()
12566 }
12567 }
12568 impl NewWithNullPtr for wire_cst_ln_url_withdraw_success_data {
12569 fn new_with_null_ptr() -> Self {
12570 Self {
12571 invoice: Default::default(),
12572 }
12573 }
12574 }
12575 impl Default for wire_cst_ln_url_withdraw_success_data {
12576 fn default() -> Self {
12577 Self::new_with_null_ptr()
12578 }
12579 }
12580 impl NewWithNullPtr for wire_cst_locale_overrides {
12581 fn new_with_null_ptr() -> Self {
12582 Self {
12583 locale: core::ptr::null_mut(),
12584 spacing: core::ptr::null_mut(),
12585 symbol: Default::default(),
12586 }
12587 }
12588 }
12589 impl Default for wire_cst_locale_overrides {
12590 fn default() -> Self {
12591 Self::new_with_null_ptr()
12592 }
12593 }
12594 impl NewWithNullPtr for wire_cst_localized_name {
12595 fn new_with_null_ptr() -> Self {
12596 Self {
12597 locale: core::ptr::null_mut(),
12598 name: core::ptr::null_mut(),
12599 }
12600 }
12601 }
12602 impl Default for wire_cst_localized_name {
12603 fn default() -> Self {
12604 Self::new_with_null_ptr()
12605 }
12606 }
12607 impl NewWithNullPtr for wire_cst_log_entry {
12608 fn new_with_null_ptr() -> Self {
12609 Self {
12610 line: core::ptr::null_mut(),
12611 level: core::ptr::null_mut(),
12612 }
12613 }
12614 }
12615 impl Default for wire_cst_log_entry {
12616 fn default() -> Self {
12617 Self::new_with_null_ptr()
12618 }
12619 }
12620 impl NewWithNullPtr for wire_cst_message_success_action_data {
12621 fn new_with_null_ptr() -> Self {
12622 Self {
12623 message: core::ptr::null_mut(),
12624 }
12625 }
12626 }
12627 impl Default for wire_cst_message_success_action_data {
12628 fn default() -> Self {
12629 Self::new_with_null_ptr()
12630 }
12631 }
12632 impl NewWithNullPtr for wire_cst_onchain_payment_limits_response {
12633 fn new_with_null_ptr() -> Self {
12634 Self {
12635 send: Default::default(),
12636 receive: Default::default(),
12637 }
12638 }
12639 }
12640 impl Default for wire_cst_onchain_payment_limits_response {
12641 fn default() -> Self {
12642 Self::new_with_null_ptr()
12643 }
12644 }
12645 impl NewWithNullPtr for wire_cst_pay_amount {
12646 fn new_with_null_ptr() -> Self {
12647 Self {
12648 tag: -1,
12649 kind: PayAmountKind { nil__: () },
12650 }
12651 }
12652 }
12653 impl Default for wire_cst_pay_amount {
12654 fn default() -> Self {
12655 Self::new_with_null_ptr()
12656 }
12657 }
12658 impl NewWithNullPtr for wire_cst_pay_onchain_request {
12659 fn new_with_null_ptr() -> Self {
12660 Self {
12661 address: core::ptr::null_mut(),
12662 prepare_response: Default::default(),
12663 }
12664 }
12665 }
12666 impl Default for wire_cst_pay_onchain_request {
12667 fn default() -> Self {
12668 Self::new_with_null_ptr()
12669 }
12670 }
12671 impl NewWithNullPtr for wire_cst_payment {
12672 fn new_with_null_ptr() -> Self {
12673 Self {
12674 destination: core::ptr::null_mut(),
12675 tx_id: core::ptr::null_mut(),
12676 unblinding_data: core::ptr::null_mut(),
12677 timestamp: Default::default(),
12678 amount_sat: Default::default(),
12679 fees_sat: Default::default(),
12680 swapper_fees_sat: core::ptr::null_mut(),
12681 payment_type: Default::default(),
12682 status: Default::default(),
12683 details: Default::default(),
12684 }
12685 }
12686 }
12687 impl Default for wire_cst_payment {
12688 fn default() -> Self {
12689 Self::new_with_null_ptr()
12690 }
12691 }
12692 impl NewWithNullPtr for wire_cst_payment_details {
12693 fn new_with_null_ptr() -> Self {
12694 Self {
12695 tag: -1,
12696 kind: PaymentDetailsKind { nil__: () },
12697 }
12698 }
12699 }
12700 impl Default for wire_cst_payment_details {
12701 fn default() -> Self {
12702 Self::new_with_null_ptr()
12703 }
12704 }
12705 impl NewWithNullPtr for wire_cst_payment_error {
12706 fn new_with_null_ptr() -> Self {
12707 Self {
12708 tag: -1,
12709 kind: PaymentErrorKind { nil__: () },
12710 }
12711 }
12712 }
12713 impl Default for wire_cst_payment_error {
12714 fn default() -> Self {
12715 Self::new_with_null_ptr()
12716 }
12717 }
12718 impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_request {
12719 fn new_with_null_ptr() -> Self {
12720 Self {
12721 provider: Default::default(),
12722 amount_sat: Default::default(),
12723 }
12724 }
12725 }
12726 impl Default for wire_cst_prepare_buy_bitcoin_request {
12727 fn default() -> Self {
12728 Self::new_with_null_ptr()
12729 }
12730 }
12731 impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_response {
12732 fn new_with_null_ptr() -> Self {
12733 Self {
12734 provider: Default::default(),
12735 amount_sat: Default::default(),
12736 fees_sat: Default::default(),
12737 }
12738 }
12739 }
12740 impl Default for wire_cst_prepare_buy_bitcoin_response {
12741 fn default() -> Self {
12742 Self::new_with_null_ptr()
12743 }
12744 }
12745 impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_request {
12746 fn new_with_null_ptr() -> Self {
12747 Self {
12748 data: Default::default(),
12749 amount: Default::default(),
12750 bip353_address: core::ptr::null_mut(),
12751 comment: core::ptr::null_mut(),
12752 validate_success_action_url: core::ptr::null_mut(),
12753 }
12754 }
12755 }
12756 impl Default for wire_cst_prepare_ln_url_pay_request {
12757 fn default() -> Self {
12758 Self::new_with_null_ptr()
12759 }
12760 }
12761 impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_response {
12762 fn new_with_null_ptr() -> Self {
12763 Self {
12764 destination: Default::default(),
12765 fees_sat: Default::default(),
12766 data: Default::default(),
12767 amount: Default::default(),
12768 comment: core::ptr::null_mut(),
12769 success_action: core::ptr::null_mut(),
12770 }
12771 }
12772 }
12773 impl Default for wire_cst_prepare_ln_url_pay_response {
12774 fn default() -> Self {
12775 Self::new_with_null_ptr()
12776 }
12777 }
12778 impl NewWithNullPtr for wire_cst_prepare_pay_onchain_request {
12779 fn new_with_null_ptr() -> Self {
12780 Self {
12781 amount: Default::default(),
12782 fee_rate_sat_per_vbyte: core::ptr::null_mut(),
12783 }
12784 }
12785 }
12786 impl Default for wire_cst_prepare_pay_onchain_request {
12787 fn default() -> Self {
12788 Self::new_with_null_ptr()
12789 }
12790 }
12791 impl NewWithNullPtr for wire_cst_prepare_pay_onchain_response {
12792 fn new_with_null_ptr() -> Self {
12793 Self {
12794 receiver_amount_sat: Default::default(),
12795 claim_fees_sat: Default::default(),
12796 total_fees_sat: Default::default(),
12797 }
12798 }
12799 }
12800 impl Default for wire_cst_prepare_pay_onchain_response {
12801 fn default() -> Self {
12802 Self::new_with_null_ptr()
12803 }
12804 }
12805 impl NewWithNullPtr for wire_cst_prepare_receive_request {
12806 fn new_with_null_ptr() -> Self {
12807 Self {
12808 payment_method: Default::default(),
12809 amount: core::ptr::null_mut(),
12810 }
12811 }
12812 }
12813 impl Default for wire_cst_prepare_receive_request {
12814 fn default() -> Self {
12815 Self::new_with_null_ptr()
12816 }
12817 }
12818 impl NewWithNullPtr for wire_cst_prepare_receive_response {
12819 fn new_with_null_ptr() -> Self {
12820 Self {
12821 payment_method: Default::default(),
12822 fees_sat: Default::default(),
12823 amount: core::ptr::null_mut(),
12824 min_payer_amount_sat: core::ptr::null_mut(),
12825 max_payer_amount_sat: core::ptr::null_mut(),
12826 swapper_feerate: core::ptr::null_mut(),
12827 }
12828 }
12829 }
12830 impl Default for wire_cst_prepare_receive_response {
12831 fn default() -> Self {
12832 Self::new_with_null_ptr()
12833 }
12834 }
12835 impl NewWithNullPtr for wire_cst_prepare_refund_request {
12836 fn new_with_null_ptr() -> Self {
12837 Self {
12838 swap_address: core::ptr::null_mut(),
12839 refund_address: core::ptr::null_mut(),
12840 fee_rate_sat_per_vbyte: Default::default(),
12841 }
12842 }
12843 }
12844 impl Default for wire_cst_prepare_refund_request {
12845 fn default() -> Self {
12846 Self::new_with_null_ptr()
12847 }
12848 }
12849 impl NewWithNullPtr for wire_cst_prepare_refund_response {
12850 fn new_with_null_ptr() -> Self {
12851 Self {
12852 tx_vsize: Default::default(),
12853 tx_fee_sat: Default::default(),
12854 last_refund_tx_id: core::ptr::null_mut(),
12855 }
12856 }
12857 }
12858 impl Default for wire_cst_prepare_refund_response {
12859 fn default() -> Self {
12860 Self::new_with_null_ptr()
12861 }
12862 }
12863 impl NewWithNullPtr for wire_cst_prepare_send_request {
12864 fn new_with_null_ptr() -> Self {
12865 Self {
12866 destination: core::ptr::null_mut(),
12867 amount: core::ptr::null_mut(),
12868 }
12869 }
12870 }
12871 impl Default for wire_cst_prepare_send_request {
12872 fn default() -> Self {
12873 Self::new_with_null_ptr()
12874 }
12875 }
12876 impl NewWithNullPtr for wire_cst_prepare_send_response {
12877 fn new_with_null_ptr() -> Self {
12878 Self {
12879 destination: Default::default(),
12880 amount: core::ptr::null_mut(),
12881 fees_sat: core::ptr::null_mut(),
12882 estimated_asset_fees: core::ptr::null_mut(),
12883 exchange_amount_sat: core::ptr::null_mut(),
12884 }
12885 }
12886 }
12887 impl Default for wire_cst_prepare_send_response {
12888 fn default() -> Self {
12889 Self::new_with_null_ptr()
12890 }
12891 }
12892 impl NewWithNullPtr for wire_cst_rate {
12893 fn new_with_null_ptr() -> Self {
12894 Self {
12895 coin: core::ptr::null_mut(),
12896 value: Default::default(),
12897 }
12898 }
12899 }
12900 impl Default for wire_cst_rate {
12901 fn default() -> Self {
12902 Self::new_with_null_ptr()
12903 }
12904 }
12905 impl NewWithNullPtr for wire_cst_receive_amount {
12906 fn new_with_null_ptr() -> Self {
12907 Self {
12908 tag: -1,
12909 kind: ReceiveAmountKind { nil__: () },
12910 }
12911 }
12912 }
12913 impl Default for wire_cst_receive_amount {
12914 fn default() -> Self {
12915 Self::new_with_null_ptr()
12916 }
12917 }
12918 impl NewWithNullPtr for wire_cst_receive_payment_request {
12919 fn new_with_null_ptr() -> Self {
12920 Self {
12921 prepare_response: Default::default(),
12922 description: core::ptr::null_mut(),
12923 use_description_hash: core::ptr::null_mut(),
12924 payer_note: core::ptr::null_mut(),
12925 }
12926 }
12927 }
12928 impl Default for wire_cst_receive_payment_request {
12929 fn default() -> Self {
12930 Self::new_with_null_ptr()
12931 }
12932 }
12933 impl NewWithNullPtr for wire_cst_receive_payment_response {
12934 fn new_with_null_ptr() -> Self {
12935 Self {
12936 destination: core::ptr::null_mut(),
12937 liquid_expiration_blockheight: core::ptr::null_mut(),
12938 bitcoin_expiration_blockheight: core::ptr::null_mut(),
12939 }
12940 }
12941 }
12942 impl Default for wire_cst_receive_payment_response {
12943 fn default() -> Self {
12944 Self::new_with_null_ptr()
12945 }
12946 }
12947 impl NewWithNullPtr for wire_cst_recommended_fees {
12948 fn new_with_null_ptr() -> Self {
12949 Self {
12950 fastest_fee: Default::default(),
12951 half_hour_fee: Default::default(),
12952 hour_fee: Default::default(),
12953 economy_fee: Default::default(),
12954 minimum_fee: Default::default(),
12955 }
12956 }
12957 }
12958 impl Default for wire_cst_recommended_fees {
12959 fn default() -> Self {
12960 Self::new_with_null_ptr()
12961 }
12962 }
12963 impl NewWithNullPtr for wire_cst_refund_request {
12964 fn new_with_null_ptr() -> Self {
12965 Self {
12966 swap_address: core::ptr::null_mut(),
12967 refund_address: core::ptr::null_mut(),
12968 fee_rate_sat_per_vbyte: Default::default(),
12969 }
12970 }
12971 }
12972 impl Default for wire_cst_refund_request {
12973 fn default() -> Self {
12974 Self::new_with_null_ptr()
12975 }
12976 }
12977 impl NewWithNullPtr for wire_cst_refund_response {
12978 fn new_with_null_ptr() -> Self {
12979 Self {
12980 refund_tx_id: core::ptr::null_mut(),
12981 }
12982 }
12983 }
12984 impl Default for wire_cst_refund_response {
12985 fn default() -> Self {
12986 Self::new_with_null_ptr()
12987 }
12988 }
12989 impl NewWithNullPtr for wire_cst_refundable_swap {
12990 fn new_with_null_ptr() -> Self {
12991 Self {
12992 swap_address: core::ptr::null_mut(),
12993 timestamp: Default::default(),
12994 amount_sat: Default::default(),
12995 last_refund_tx_id: core::ptr::null_mut(),
12996 }
12997 }
12998 }
12999 impl Default for wire_cst_refundable_swap {
13000 fn default() -> Self {
13001 Self::new_with_null_ptr()
13002 }
13003 }
13004 impl NewWithNullPtr for wire_cst_restore_request {
13005 fn new_with_null_ptr() -> Self {
13006 Self {
13007 backup_path: core::ptr::null_mut(),
13008 }
13009 }
13010 }
13011 impl Default for wire_cst_restore_request {
13012 fn default() -> Self {
13013 Self::new_with_null_ptr()
13014 }
13015 }
13016 impl NewWithNullPtr for wire_cst_route_hint {
13017 fn new_with_null_ptr() -> Self {
13018 Self {
13019 hops: core::ptr::null_mut(),
13020 }
13021 }
13022 }
13023 impl Default for wire_cst_route_hint {
13024 fn default() -> Self {
13025 Self::new_with_null_ptr()
13026 }
13027 }
13028 impl NewWithNullPtr for wire_cst_route_hint_hop {
13029 fn new_with_null_ptr() -> Self {
13030 Self {
13031 src_node_id: core::ptr::null_mut(),
13032 short_channel_id: core::ptr::null_mut(),
13033 fees_base_msat: Default::default(),
13034 fees_proportional_millionths: Default::default(),
13035 cltv_expiry_delta: Default::default(),
13036 htlc_minimum_msat: core::ptr::null_mut(),
13037 htlc_maximum_msat: core::ptr::null_mut(),
13038 }
13039 }
13040 }
13041 impl Default for wire_cst_route_hint_hop {
13042 fn default() -> Self {
13043 Self::new_with_null_ptr()
13044 }
13045 }
13046 impl NewWithNullPtr for wire_cst_sdk_error {
13047 fn new_with_null_ptr() -> Self {
13048 Self {
13049 tag: -1,
13050 kind: SdkErrorKind { nil__: () },
13051 }
13052 }
13053 }
13054 impl Default for wire_cst_sdk_error {
13055 fn default() -> Self {
13056 Self::new_with_null_ptr()
13057 }
13058 }
13059 impl NewWithNullPtr for wire_cst_sdk_event {
13060 fn new_with_null_ptr() -> Self {
13061 Self {
13062 tag: -1,
13063 kind: SdkEventKind { nil__: () },
13064 }
13065 }
13066 }
13067 impl Default for wire_cst_sdk_event {
13068 fn default() -> Self {
13069 Self::new_with_null_ptr()
13070 }
13071 }
13072 impl NewWithNullPtr for wire_cst_send_destination {
13073 fn new_with_null_ptr() -> Self {
13074 Self {
13075 tag: -1,
13076 kind: SendDestinationKind { nil__: () },
13077 }
13078 }
13079 }
13080 impl Default for wire_cst_send_destination {
13081 fn default() -> Self {
13082 Self::new_with_null_ptr()
13083 }
13084 }
13085 impl NewWithNullPtr for wire_cst_send_payment_request {
13086 fn new_with_null_ptr() -> Self {
13087 Self {
13088 prepare_response: Default::default(),
13089 use_asset_fees: core::ptr::null_mut(),
13090 payer_note: core::ptr::null_mut(),
13091 }
13092 }
13093 }
13094 impl Default for wire_cst_send_payment_request {
13095 fn default() -> Self {
13096 Self::new_with_null_ptr()
13097 }
13098 }
13099 impl NewWithNullPtr for wire_cst_send_payment_response {
13100 fn new_with_null_ptr() -> Self {
13101 Self {
13102 payment: Default::default(),
13103 }
13104 }
13105 }
13106 impl Default for wire_cst_send_payment_response {
13107 fn default() -> Self {
13108 Self::new_with_null_ptr()
13109 }
13110 }
13111 impl NewWithNullPtr for wire_cst_sign_message_request {
13112 fn new_with_null_ptr() -> Self {
13113 Self {
13114 message: core::ptr::null_mut(),
13115 }
13116 }
13117 }
13118 impl Default for wire_cst_sign_message_request {
13119 fn default() -> Self {
13120 Self::new_with_null_ptr()
13121 }
13122 }
13123 impl NewWithNullPtr for wire_cst_sign_message_response {
13124 fn new_with_null_ptr() -> Self {
13125 Self {
13126 signature: core::ptr::null_mut(),
13127 }
13128 }
13129 }
13130 impl Default for wire_cst_sign_message_response {
13131 fn default() -> Self {
13132 Self::new_with_null_ptr()
13133 }
13134 }
13135 impl NewWithNullPtr for wire_cst_success_action {
13136 fn new_with_null_ptr() -> Self {
13137 Self {
13138 tag: -1,
13139 kind: SuccessActionKind { nil__: () },
13140 }
13141 }
13142 }
13143 impl Default for wire_cst_success_action {
13144 fn default() -> Self {
13145 Self::new_with_null_ptr()
13146 }
13147 }
13148 impl NewWithNullPtr for wire_cst_success_action_processed {
13149 fn new_with_null_ptr() -> Self {
13150 Self {
13151 tag: -1,
13152 kind: SuccessActionProcessedKind { nil__: () },
13153 }
13154 }
13155 }
13156 impl Default for wire_cst_success_action_processed {
13157 fn default() -> Self {
13158 Self::new_with_null_ptr()
13159 }
13160 }
13161 impl NewWithNullPtr for wire_cst_symbol {
13162 fn new_with_null_ptr() -> Self {
13163 Self {
13164 grapheme: core::ptr::null_mut(),
13165 template: core::ptr::null_mut(),
13166 rtl: core::ptr::null_mut(),
13167 position: core::ptr::null_mut(),
13168 }
13169 }
13170 }
13171 impl Default for wire_cst_symbol {
13172 fn default() -> Self {
13173 Self::new_with_null_ptr()
13174 }
13175 }
13176 impl NewWithNullPtr for wire_cst_url_success_action_data {
13177 fn new_with_null_ptr() -> Self {
13178 Self {
13179 description: core::ptr::null_mut(),
13180 url: core::ptr::null_mut(),
13181 matches_callback_domain: Default::default(),
13182 }
13183 }
13184 }
13185 impl Default for wire_cst_url_success_action_data {
13186 fn default() -> Self {
13187 Self::new_with_null_ptr()
13188 }
13189 }
13190 impl NewWithNullPtr for wire_cst_wallet_info {
13191 fn new_with_null_ptr() -> Self {
13192 Self {
13193 balance_sat: Default::default(),
13194 pending_send_sat: Default::default(),
13195 pending_receive_sat: Default::default(),
13196 fingerprint: core::ptr::null_mut(),
13197 pubkey: core::ptr::null_mut(),
13198 asset_balances: core::ptr::null_mut(),
13199 }
13200 }
13201 }
13202 impl Default for wire_cst_wallet_info {
13203 fn default() -> Self {
13204 Self::new_with_null_ptr()
13205 }
13206 }
13207
13208 #[unsafe(no_mangle)]
13209 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees(
13210 port_: i64,
13211 that: usize,
13212 req: *mut wire_cst_accept_payment_proposed_fees_request,
13213 ) {
13214 wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(port_, that, req)
13215 }
13216
13217 #[unsafe(no_mangle)]
13218 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_add_event_listener(
13219 port_: i64,
13220 that: usize,
13221 listener: *mut wire_cst_list_prim_u_8_strict,
13222 ) {
13223 wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(port_, that, listener)
13224 }
13225
13226 #[unsafe(no_mangle)]
13227 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_backup(
13228 that: usize,
13229 req: *mut wire_cst_backup_request,
13230 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13231 wire__crate__bindings__BindingLiquidSdk_backup_impl(that, req)
13232 }
13233
13234 #[unsafe(no_mangle)]
13235 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_buy_bitcoin(
13236 port_: i64,
13237 that: usize,
13238 req: *mut wire_cst_buy_bitcoin_request,
13239 ) {
13240 wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(port_, that, req)
13241 }
13242
13243 #[unsafe(no_mangle)]
13244 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_check_message(
13245 that: usize,
13246 req: *mut wire_cst_check_message_request,
13247 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13248 wire__crate__bindings__BindingLiquidSdk_check_message_impl(that, req)
13249 }
13250
13251 #[unsafe(no_mangle)]
13252 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice(
13253 port_: i64,
13254 that: usize,
13255 req: *mut wire_cst_create_bolt_12_invoice_request,
13256 ) {
13257 wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(port_, that, req)
13258 }
13259
13260 #[unsafe(no_mangle)]
13261 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_disconnect(
13262 port_: i64,
13263 that: usize,
13264 ) {
13265 wire__crate__bindings__BindingLiquidSdk_disconnect_impl(port_, that)
13266 }
13267
13268 #[unsafe(no_mangle)]
13269 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache(
13270 that: usize,
13271 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13272 wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(that)
13273 }
13274
13275 #[unsafe(no_mangle)]
13276 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates(
13277 port_: i64,
13278 that: usize,
13279 ) {
13280 wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(port_, that)
13281 }
13282
13283 #[unsafe(no_mangle)]
13284 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
13285 port_: i64,
13286 that: usize,
13287 ) {
13288 wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(port_, that)
13289 }
13290
13291 #[unsafe(no_mangle)]
13292 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
13293 port_: i64,
13294 that: usize,
13295 ) {
13296 wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(port_, that)
13297 }
13298
13299 #[unsafe(no_mangle)]
13300 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees(
13301 port_: i64,
13302 that: usize,
13303 req: *mut wire_cst_fetch_payment_proposed_fees_request,
13304 ) {
13305 wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(port_, that, req)
13306 }
13307
13308 #[unsafe(no_mangle)]
13309 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info(
13310 port_: i64,
13311 that: usize,
13312 ) {
13313 wire__crate__bindings__BindingLiquidSdk_get_info_impl(port_, that)
13314 }
13315
13316 #[unsafe(no_mangle)]
13317 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_payment(
13318 port_: i64,
13319 that: usize,
13320 req: *mut wire_cst_get_payment_request,
13321 ) {
13322 wire__crate__bindings__BindingLiquidSdk_get_payment_impl(port_, that, req)
13323 }
13324
13325 #[unsafe(no_mangle)]
13326 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies(
13327 port_: i64,
13328 that: usize,
13329 ) {
13330 wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(port_, that)
13331 }
13332
13333 #[unsafe(no_mangle)]
13334 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_payments(
13335 port_: i64,
13336 that: usize,
13337 req: *mut wire_cst_list_payments_request,
13338 ) {
13339 wire__crate__bindings__BindingLiquidSdk_list_payments_impl(port_, that, req)
13340 }
13341
13342 #[unsafe(no_mangle)]
13343 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_refundables(
13344 port_: i64,
13345 that: usize,
13346 ) {
13347 wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(port_, that)
13348 }
13349
13350 #[unsafe(no_mangle)]
13351 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_auth(
13352 port_: i64,
13353 that: usize,
13354 req_data: *mut wire_cst_ln_url_auth_request_data,
13355 ) {
13356 wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(port_, that, req_data)
13357 }
13358
13359 #[unsafe(no_mangle)]
13360 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_pay(
13361 port_: i64,
13362 that: usize,
13363 req: *mut wire_cst_ln_url_pay_request,
13364 ) {
13365 wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(port_, that, req)
13366 }
13367
13368 #[unsafe(no_mangle)]
13369 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw(
13370 port_: i64,
13371 that: usize,
13372 req: *mut wire_cst_ln_url_withdraw_request,
13373 ) {
13374 wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(port_, that, req)
13375 }
13376
13377 #[unsafe(no_mangle)]
13378 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_parse(
13379 port_: i64,
13380 that: usize,
13381 input: *mut wire_cst_list_prim_u_8_strict,
13382 ) {
13383 wire__crate__bindings__BindingLiquidSdk_parse_impl(port_, that, input)
13384 }
13385
13386 #[unsafe(no_mangle)]
13387 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_pay_onchain(
13388 port_: i64,
13389 that: usize,
13390 req: *mut wire_cst_pay_onchain_request,
13391 ) {
13392 wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(port_, that, req)
13393 }
13394
13395 #[unsafe(no_mangle)]
13396 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin(
13397 port_: i64,
13398 that: usize,
13399 req: *mut wire_cst_prepare_buy_bitcoin_request,
13400 ) {
13401 wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(port_, that, req)
13402 }
13403
13404 #[unsafe(no_mangle)]
13405 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay(
13406 port_: i64,
13407 that: usize,
13408 req: *mut wire_cst_prepare_ln_url_pay_request,
13409 ) {
13410 wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(port_, that, req)
13411 }
13412
13413 #[unsafe(no_mangle)]
13414 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain(
13415 port_: i64,
13416 that: usize,
13417 req: *mut wire_cst_prepare_pay_onchain_request,
13418 ) {
13419 wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(port_, that, req)
13420 }
13421
13422 #[unsafe(no_mangle)]
13423 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment(
13424 port_: i64,
13425 that: usize,
13426 req: *mut wire_cst_prepare_receive_request,
13427 ) {
13428 wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(port_, that, req)
13429 }
13430
13431 #[unsafe(no_mangle)]
13432 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_refund(
13433 port_: i64,
13434 that: usize,
13435 req: *mut wire_cst_prepare_refund_request,
13436 ) {
13437 wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(port_, that, req)
13438 }
13439
13440 #[unsafe(no_mangle)]
13441 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_send_payment(
13442 port_: i64,
13443 that: usize,
13444 req: *mut wire_cst_prepare_send_request,
13445 ) {
13446 wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(port_, that, req)
13447 }
13448
13449 #[unsafe(no_mangle)]
13450 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_receive_payment(
13451 port_: i64,
13452 that: usize,
13453 req: *mut wire_cst_receive_payment_request,
13454 ) {
13455 wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(port_, that, req)
13456 }
13457
13458 #[unsafe(no_mangle)]
13459 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_recommended_fees(
13460 port_: i64,
13461 that: usize,
13462 ) {
13463 wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(port_, that)
13464 }
13465
13466 #[unsafe(no_mangle)]
13467 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_refund(
13468 port_: i64,
13469 that: usize,
13470 req: *mut wire_cst_refund_request,
13471 ) {
13472 wire__crate__bindings__BindingLiquidSdk_refund_impl(port_, that, req)
13473 }
13474
13475 #[unsafe(no_mangle)]
13476 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_register_webhook(
13477 port_: i64,
13478 that: usize,
13479 webhook_url: *mut wire_cst_list_prim_u_8_strict,
13480 ) {
13481 wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(port_, that, webhook_url)
13482 }
13483
13484 #[unsafe(no_mangle)]
13485 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps(
13486 port_: i64,
13487 that: usize,
13488 ) {
13489 wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(port_, that)
13490 }
13491
13492 #[unsafe(no_mangle)]
13493 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_restore(
13494 that: usize,
13495 req: *mut wire_cst_restore_request,
13496 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13497 wire__crate__bindings__BindingLiquidSdk_restore_impl(that, req)
13498 }
13499
13500 #[unsafe(no_mangle)]
13501 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_send_payment(
13502 port_: i64,
13503 that: usize,
13504 req: *mut wire_cst_send_payment_request,
13505 ) {
13506 wire__crate__bindings__BindingLiquidSdk_send_payment_impl(port_, that, req)
13507 }
13508
13509 #[unsafe(no_mangle)]
13510 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sign_message(
13511 that: usize,
13512 req: *mut wire_cst_sign_message_request,
13513 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13514 wire__crate__bindings__BindingLiquidSdk_sign_message_impl(that, req)
13515 }
13516
13517 #[unsafe(no_mangle)]
13518 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sync(
13519 port_: i64,
13520 that: usize,
13521 ) {
13522 wire__crate__bindings__BindingLiquidSdk_sync_impl(port_, that)
13523 }
13524
13525 #[unsafe(no_mangle)]
13526 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_unregister_webhook(
13527 port_: i64,
13528 that: usize,
13529 ) {
13530 wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(port_, that)
13531 }
13532
13533 #[unsafe(no_mangle)]
13534 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__binding_event_listener_on_event(
13535 port_: i64,
13536 that: *mut wire_cst_binding_event_listener,
13537 e: *mut wire_cst_sdk_event,
13538 ) {
13539 wire__crate__bindings__binding_event_listener_on_event_impl(port_, that, e)
13540 }
13541
13542 #[unsafe(no_mangle)]
13543 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__breez_log_stream(
13544 port_: i64,
13545 s: *mut wire_cst_list_prim_u_8_strict,
13546 ) {
13547 wire__crate__bindings__breez_log_stream_impl(port_, s)
13548 }
13549
13550 #[unsafe(no_mangle)]
13551 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__connect(
13552 port_: i64,
13553 req: *mut wire_cst_connect_request,
13554 ) {
13555 wire__crate__bindings__connect_impl(port_, req)
13556 }
13557
13558 #[unsafe(no_mangle)]
13559 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__default_config(
13560 network: i32,
13561 breez_api_key: *mut wire_cst_list_prim_u_8_strict,
13562 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13563 wire__crate__bindings__default_config_impl(network, breez_api_key)
13564 }
13565
13566 #[unsafe(no_mangle)]
13567 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__parse_invoice(
13568 input: *mut wire_cst_list_prim_u_8_strict,
13569 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13570 wire__crate__bindings__parse_invoice_impl(input)
13571 }
13572
13573 #[unsafe(no_mangle)]
13574 pub extern "C" fn frbgen_breez_liquid_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13575 ptr: *const std::ffi::c_void,
13576 ) {
13577 unsafe {
13578 StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::increment_strong_count(ptr as _);
13579 }
13580 }
13581
13582 #[unsafe(no_mangle)]
13583 pub extern "C" fn frbgen_breez_liquid_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13584 ptr: *const std::ffi::c_void,
13585 ) {
13586 unsafe {
13587 StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::decrement_strong_count(ptr as _);
13588 }
13589 }
13590
13591 #[unsafe(no_mangle)]
13592 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_accept_payment_proposed_fees_request(
13593 ) -> *mut wire_cst_accept_payment_proposed_fees_request {
13594 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13595 wire_cst_accept_payment_proposed_fees_request::new_with_null_ptr(),
13596 )
13597 }
13598
13599 #[unsafe(no_mangle)]
13600 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data(
13601 ) -> *mut wire_cst_aes_success_action_data {
13602 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13603 wire_cst_aes_success_action_data::new_with_null_ptr(),
13604 )
13605 }
13606
13607 #[unsafe(no_mangle)]
13608 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_decrypted(
13609 ) -> *mut wire_cst_aes_success_action_data_decrypted {
13610 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13611 wire_cst_aes_success_action_data_decrypted::new_with_null_ptr(),
13612 )
13613 }
13614
13615 #[unsafe(no_mangle)]
13616 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_result(
13617 ) -> *mut wire_cst_aes_success_action_data_result {
13618 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13619 wire_cst_aes_success_action_data_result::new_with_null_ptr(),
13620 )
13621 }
13622
13623 #[unsafe(no_mangle)]
13624 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_amount() -> *mut wire_cst_amount {
13625 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_amount::new_with_null_ptr())
13626 }
13627
13628 #[unsafe(no_mangle)]
13629 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_asset_info(
13630 ) -> *mut wire_cst_asset_info {
13631 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13632 wire_cst_asset_info::new_with_null_ptr(),
13633 )
13634 }
13635
13636 #[unsafe(no_mangle)]
13637 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_backup_request(
13638 ) -> *mut wire_cst_backup_request {
13639 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13640 wire_cst_backup_request::new_with_null_ptr(),
13641 )
13642 }
13643
13644 #[unsafe(no_mangle)]
13645 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_binding_event_listener(
13646 ) -> *mut wire_cst_binding_event_listener {
13647 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13648 wire_cst_binding_event_listener::new_with_null_ptr(),
13649 )
13650 }
13651
13652 #[unsafe(no_mangle)]
13653 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bitcoin_address_data(
13654 ) -> *mut wire_cst_bitcoin_address_data {
13655 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13656 wire_cst_bitcoin_address_data::new_with_null_ptr(),
13657 )
13658 }
13659
13660 #[unsafe(no_mangle)]
13661 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bool(value: bool) -> *mut bool {
13662 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13663 }
13664
13665 #[unsafe(no_mangle)]
13666 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_buy_bitcoin_request(
13667 ) -> *mut wire_cst_buy_bitcoin_request {
13668 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13669 wire_cst_buy_bitcoin_request::new_with_null_ptr(),
13670 )
13671 }
13672
13673 #[unsafe(no_mangle)]
13674 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_check_message_request(
13675 ) -> *mut wire_cst_check_message_request {
13676 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13677 wire_cst_check_message_request::new_with_null_ptr(),
13678 )
13679 }
13680
13681 #[unsafe(no_mangle)]
13682 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_connect_request(
13683 ) -> *mut wire_cst_connect_request {
13684 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13685 wire_cst_connect_request::new_with_null_ptr(),
13686 )
13687 }
13688
13689 #[unsafe(no_mangle)]
13690 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_create_bolt_12_invoice_request(
13691 ) -> *mut wire_cst_create_bolt_12_invoice_request {
13692 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13693 wire_cst_create_bolt_12_invoice_request::new_with_null_ptr(),
13694 )
13695 }
13696
13697 #[unsafe(no_mangle)]
13698 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_f_64(value: f64) -> *mut f64 {
13699 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13700 }
13701
13702 #[unsafe(no_mangle)]
13703 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_fetch_payment_proposed_fees_request(
13704 ) -> *mut wire_cst_fetch_payment_proposed_fees_request {
13705 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13706 wire_cst_fetch_payment_proposed_fees_request::new_with_null_ptr(),
13707 )
13708 }
13709
13710 #[unsafe(no_mangle)]
13711 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_get_payment_request(
13712 ) -> *mut wire_cst_get_payment_request {
13713 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13714 wire_cst_get_payment_request::new_with_null_ptr(),
13715 )
13716 }
13717
13718 #[unsafe(no_mangle)]
13719 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_i_64(value: i64) -> *mut i64 {
13720 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13721 }
13722
13723 #[unsafe(no_mangle)]
13724 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_liquid_address_data(
13725 ) -> *mut wire_cst_liquid_address_data {
13726 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13727 wire_cst_liquid_address_data::new_with_null_ptr(),
13728 )
13729 }
13730
13731 #[unsafe(no_mangle)]
13732 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payment_details(
13733 ) -> *mut wire_cst_list_payment_details {
13734 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13735 wire_cst_list_payment_details::new_with_null_ptr(),
13736 )
13737 }
13738
13739 #[unsafe(no_mangle)]
13740 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payments_request(
13741 ) -> *mut wire_cst_list_payments_request {
13742 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13743 wire_cst_list_payments_request::new_with_null_ptr(),
13744 )
13745 }
13746
13747 #[unsafe(no_mangle)]
13748 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_invoice(
13749 ) -> *mut wire_cst_ln_invoice {
13750 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13751 wire_cst_ln_invoice::new_with_null_ptr(),
13752 )
13753 }
13754
13755 #[unsafe(no_mangle)]
13756 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_offer() -> *mut wire_cst_ln_offer {
13757 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_ln_offer::new_with_null_ptr())
13758 }
13759
13760 #[unsafe(no_mangle)]
13761 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_auth_request_data(
13762 ) -> *mut wire_cst_ln_url_auth_request_data {
13763 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13764 wire_cst_ln_url_auth_request_data::new_with_null_ptr(),
13765 )
13766 }
13767
13768 #[unsafe(no_mangle)]
13769 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_error_data(
13770 ) -> *mut wire_cst_ln_url_error_data {
13771 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13772 wire_cst_ln_url_error_data::new_with_null_ptr(),
13773 )
13774 }
13775
13776 #[unsafe(no_mangle)]
13777 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_info(
13778 ) -> *mut wire_cst_ln_url_info {
13779 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13780 wire_cst_ln_url_info::new_with_null_ptr(),
13781 )
13782 }
13783
13784 #[unsafe(no_mangle)]
13785 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_error_data(
13786 ) -> *mut wire_cst_ln_url_pay_error_data {
13787 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13788 wire_cst_ln_url_pay_error_data::new_with_null_ptr(),
13789 )
13790 }
13791
13792 #[unsafe(no_mangle)]
13793 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request(
13794 ) -> *mut wire_cst_ln_url_pay_request {
13795 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13796 wire_cst_ln_url_pay_request::new_with_null_ptr(),
13797 )
13798 }
13799
13800 #[unsafe(no_mangle)]
13801 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request_data(
13802 ) -> *mut wire_cst_ln_url_pay_request_data {
13803 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13804 wire_cst_ln_url_pay_request_data::new_with_null_ptr(),
13805 )
13806 }
13807
13808 #[unsafe(no_mangle)]
13809 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_success_data(
13810 ) -> *mut wire_cst_ln_url_pay_success_data {
13811 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13812 wire_cst_ln_url_pay_success_data::new_with_null_ptr(),
13813 )
13814 }
13815
13816 #[unsafe(no_mangle)]
13817 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request(
13818 ) -> *mut wire_cst_ln_url_withdraw_request {
13819 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13820 wire_cst_ln_url_withdraw_request::new_with_null_ptr(),
13821 )
13822 }
13823
13824 #[unsafe(no_mangle)]
13825 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request_data(
13826 ) -> *mut wire_cst_ln_url_withdraw_request_data {
13827 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13828 wire_cst_ln_url_withdraw_request_data::new_with_null_ptr(),
13829 )
13830 }
13831
13832 #[unsafe(no_mangle)]
13833 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_success_data(
13834 ) -> *mut wire_cst_ln_url_withdraw_success_data {
13835 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13836 wire_cst_ln_url_withdraw_success_data::new_with_null_ptr(),
13837 )
13838 }
13839
13840 #[unsafe(no_mangle)]
13841 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_message_success_action_data(
13842 ) -> *mut wire_cst_message_success_action_data {
13843 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13844 wire_cst_message_success_action_data::new_with_null_ptr(),
13845 )
13846 }
13847
13848 #[unsafe(no_mangle)]
13849 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_amount(
13850 ) -> *mut wire_cst_pay_amount {
13851 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13852 wire_cst_pay_amount::new_with_null_ptr(),
13853 )
13854 }
13855
13856 #[unsafe(no_mangle)]
13857 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_onchain_request(
13858 ) -> *mut wire_cst_pay_onchain_request {
13859 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13860 wire_cst_pay_onchain_request::new_with_null_ptr(),
13861 )
13862 }
13863
13864 #[unsafe(no_mangle)]
13865 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_payment() -> *mut wire_cst_payment {
13866 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_payment::new_with_null_ptr())
13867 }
13868
13869 #[unsafe(no_mangle)]
13870 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_buy_bitcoin_request(
13871 ) -> *mut wire_cst_prepare_buy_bitcoin_request {
13872 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13873 wire_cst_prepare_buy_bitcoin_request::new_with_null_ptr(),
13874 )
13875 }
13876
13877 #[unsafe(no_mangle)]
13878 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_ln_url_pay_request(
13879 ) -> *mut wire_cst_prepare_ln_url_pay_request {
13880 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13881 wire_cst_prepare_ln_url_pay_request::new_with_null_ptr(),
13882 )
13883 }
13884
13885 #[unsafe(no_mangle)]
13886 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_pay_onchain_request(
13887 ) -> *mut wire_cst_prepare_pay_onchain_request {
13888 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13889 wire_cst_prepare_pay_onchain_request::new_with_null_ptr(),
13890 )
13891 }
13892
13893 #[unsafe(no_mangle)]
13894 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_receive_request(
13895 ) -> *mut wire_cst_prepare_receive_request {
13896 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13897 wire_cst_prepare_receive_request::new_with_null_ptr(),
13898 )
13899 }
13900
13901 #[unsafe(no_mangle)]
13902 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_refund_request(
13903 ) -> *mut wire_cst_prepare_refund_request {
13904 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13905 wire_cst_prepare_refund_request::new_with_null_ptr(),
13906 )
13907 }
13908
13909 #[unsafe(no_mangle)]
13910 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_send_request(
13911 ) -> *mut wire_cst_prepare_send_request {
13912 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13913 wire_cst_prepare_send_request::new_with_null_ptr(),
13914 )
13915 }
13916
13917 #[unsafe(no_mangle)]
13918 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_amount(
13919 ) -> *mut wire_cst_receive_amount {
13920 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13921 wire_cst_receive_amount::new_with_null_ptr(),
13922 )
13923 }
13924
13925 #[unsafe(no_mangle)]
13926 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_payment_request(
13927 ) -> *mut wire_cst_receive_payment_request {
13928 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13929 wire_cst_receive_payment_request::new_with_null_ptr(),
13930 )
13931 }
13932
13933 #[unsafe(no_mangle)]
13934 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_refund_request(
13935 ) -> *mut wire_cst_refund_request {
13936 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13937 wire_cst_refund_request::new_with_null_ptr(),
13938 )
13939 }
13940
13941 #[unsafe(no_mangle)]
13942 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_restore_request(
13943 ) -> *mut wire_cst_restore_request {
13944 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13945 wire_cst_restore_request::new_with_null_ptr(),
13946 )
13947 }
13948
13949 #[unsafe(no_mangle)]
13950 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sdk_event() -> *mut wire_cst_sdk_event
13951 {
13952 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_sdk_event::new_with_null_ptr())
13953 }
13954
13955 #[unsafe(no_mangle)]
13956 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_send_payment_request(
13957 ) -> *mut wire_cst_send_payment_request {
13958 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13959 wire_cst_send_payment_request::new_with_null_ptr(),
13960 )
13961 }
13962
13963 #[unsafe(no_mangle)]
13964 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sign_message_request(
13965 ) -> *mut wire_cst_sign_message_request {
13966 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13967 wire_cst_sign_message_request::new_with_null_ptr(),
13968 )
13969 }
13970
13971 #[unsafe(no_mangle)]
13972 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action(
13973 ) -> *mut wire_cst_success_action {
13974 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13975 wire_cst_success_action::new_with_null_ptr(),
13976 )
13977 }
13978
13979 #[unsafe(no_mangle)]
13980 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action_processed(
13981 ) -> *mut wire_cst_success_action_processed {
13982 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13983 wire_cst_success_action_processed::new_with_null_ptr(),
13984 )
13985 }
13986
13987 #[unsafe(no_mangle)]
13988 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_symbol() -> *mut wire_cst_symbol {
13989 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_symbol::new_with_null_ptr())
13990 }
13991
13992 #[unsafe(no_mangle)]
13993 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_32(value: u32) -> *mut u32 {
13994 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13995 }
13996
13997 #[unsafe(no_mangle)]
13998 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_64(value: u64) -> *mut u64 {
13999 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
14000 }
14001
14002 #[unsafe(no_mangle)]
14003 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_url_success_action_data(
14004 ) -> *mut wire_cst_url_success_action_data {
14005 flutter_rust_bridge::for_generated::new_leak_box_ptr(
14006 wire_cst_url_success_action_data::new_with_null_ptr(),
14007 )
14008 }
14009
14010 #[unsafe(no_mangle)]
14011 pub extern "C" fn frbgen_breez_liquid_cst_new_list_String(
14012 len: i32,
14013 ) -> *mut wire_cst_list_String {
14014 let wrap = wire_cst_list_String {
14015 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14016 <*mut wire_cst_list_prim_u_8_strict>::new_with_null_ptr(),
14017 len,
14018 ),
14019 len,
14020 };
14021 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14022 }
14023
14024 #[unsafe(no_mangle)]
14025 pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_balance(
14026 len: i32,
14027 ) -> *mut wire_cst_list_asset_balance {
14028 let wrap = wire_cst_list_asset_balance {
14029 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14030 <wire_cst_asset_balance>::new_with_null_ptr(),
14031 len,
14032 ),
14033 len,
14034 };
14035 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14036 }
14037
14038 #[unsafe(no_mangle)]
14039 pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_metadata(
14040 len: i32,
14041 ) -> *mut wire_cst_list_asset_metadata {
14042 let wrap = wire_cst_list_asset_metadata {
14043 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14044 <wire_cst_asset_metadata>::new_with_null_ptr(),
14045 len,
14046 ),
14047 len,
14048 };
14049 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14050 }
14051
14052 #[unsafe(no_mangle)]
14053 pub extern "C" fn frbgen_breez_liquid_cst_new_list_external_input_parser(
14054 len: i32,
14055 ) -> *mut wire_cst_list_external_input_parser {
14056 let wrap = wire_cst_list_external_input_parser {
14057 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14058 <wire_cst_external_input_parser>::new_with_null_ptr(),
14059 len,
14060 ),
14061 len,
14062 };
14063 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14064 }
14065
14066 #[unsafe(no_mangle)]
14067 pub extern "C" fn frbgen_breez_liquid_cst_new_list_fiat_currency(
14068 len: i32,
14069 ) -> *mut wire_cst_list_fiat_currency {
14070 let wrap = wire_cst_list_fiat_currency {
14071 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14072 <wire_cst_fiat_currency>::new_with_null_ptr(),
14073 len,
14074 ),
14075 len,
14076 };
14077 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14078 }
14079
14080 #[unsafe(no_mangle)]
14081 pub extern "C" fn frbgen_breez_liquid_cst_new_list_ln_offer_blinded_path(
14082 len: i32,
14083 ) -> *mut wire_cst_list_ln_offer_blinded_path {
14084 let wrap = wire_cst_list_ln_offer_blinded_path {
14085 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14086 <wire_cst_ln_offer_blinded_path>::new_with_null_ptr(),
14087 len,
14088 ),
14089 len,
14090 };
14091 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14092 }
14093
14094 #[unsafe(no_mangle)]
14095 pub extern "C" fn frbgen_breez_liquid_cst_new_list_locale_overrides(
14096 len: i32,
14097 ) -> *mut wire_cst_list_locale_overrides {
14098 let wrap = wire_cst_list_locale_overrides {
14099 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14100 <wire_cst_locale_overrides>::new_with_null_ptr(),
14101 len,
14102 ),
14103 len,
14104 };
14105 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14106 }
14107
14108 #[unsafe(no_mangle)]
14109 pub extern "C" fn frbgen_breez_liquid_cst_new_list_localized_name(
14110 len: i32,
14111 ) -> *mut wire_cst_list_localized_name {
14112 let wrap = wire_cst_list_localized_name {
14113 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14114 <wire_cst_localized_name>::new_with_null_ptr(),
14115 len,
14116 ),
14117 len,
14118 };
14119 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14120 }
14121
14122 #[unsafe(no_mangle)]
14123 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment(
14124 len: i32,
14125 ) -> *mut wire_cst_list_payment {
14126 let wrap = wire_cst_list_payment {
14127 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14128 <wire_cst_payment>::new_with_null_ptr(),
14129 len,
14130 ),
14131 len,
14132 };
14133 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14134 }
14135
14136 #[unsafe(no_mangle)]
14137 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_state(
14138 len: i32,
14139 ) -> *mut wire_cst_list_payment_state {
14140 let wrap = wire_cst_list_payment_state {
14141 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14142 len,
14143 };
14144 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14145 }
14146
14147 #[unsafe(no_mangle)]
14148 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_type(
14149 len: i32,
14150 ) -> *mut wire_cst_list_payment_type {
14151 let wrap = wire_cst_list_payment_type {
14152 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14153 len,
14154 };
14155 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14156 }
14157
14158 #[unsafe(no_mangle)]
14159 pub extern "C" fn frbgen_breez_liquid_cst_new_list_prim_u_8_strict(
14160 len: i32,
14161 ) -> *mut wire_cst_list_prim_u_8_strict {
14162 let ans = wire_cst_list_prim_u_8_strict {
14163 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14164 len,
14165 };
14166 flutter_rust_bridge::for_generated::new_leak_box_ptr(ans)
14167 }
14168
14169 #[unsafe(no_mangle)]
14170 pub extern "C" fn frbgen_breez_liquid_cst_new_list_rate(len: i32) -> *mut wire_cst_list_rate {
14171 let wrap = wire_cst_list_rate {
14172 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14173 <wire_cst_rate>::new_with_null_ptr(),
14174 len,
14175 ),
14176 len,
14177 };
14178 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14179 }
14180
14181 #[unsafe(no_mangle)]
14182 pub extern "C" fn frbgen_breez_liquid_cst_new_list_refundable_swap(
14183 len: i32,
14184 ) -> *mut wire_cst_list_refundable_swap {
14185 let wrap = wire_cst_list_refundable_swap {
14186 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14187 <wire_cst_refundable_swap>::new_with_null_ptr(),
14188 len,
14189 ),
14190 len,
14191 };
14192 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14193 }
14194
14195 #[unsafe(no_mangle)]
14196 pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint(
14197 len: i32,
14198 ) -> *mut wire_cst_list_route_hint {
14199 let wrap = wire_cst_list_route_hint {
14200 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14201 <wire_cst_route_hint>::new_with_null_ptr(),
14202 len,
14203 ),
14204 len,
14205 };
14206 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14207 }
14208
14209 #[unsafe(no_mangle)]
14210 pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint_hop(
14211 len: i32,
14212 ) -> *mut wire_cst_list_route_hint_hop {
14213 let wrap = wire_cst_list_route_hint_hop {
14214 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14215 <wire_cst_route_hint_hop>::new_with_null_ptr(),
14216 len,
14217 ),
14218 len,
14219 };
14220 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14221 }
14222
14223 #[repr(C)]
14224 #[derive(Clone, Copy)]
14225 pub struct wire_cst_accept_payment_proposed_fees_request {
14226 response: wire_cst_fetch_payment_proposed_fees_response,
14227 }
14228 #[repr(C)]
14229 #[derive(Clone, Copy)]
14230 pub struct wire_cst_aes_success_action_data {
14231 description: *mut wire_cst_list_prim_u_8_strict,
14232 ciphertext: *mut wire_cst_list_prim_u_8_strict,
14233 iv: *mut wire_cst_list_prim_u_8_strict,
14234 }
14235 #[repr(C)]
14236 #[derive(Clone, Copy)]
14237 pub struct wire_cst_aes_success_action_data_decrypted {
14238 description: *mut wire_cst_list_prim_u_8_strict,
14239 plaintext: *mut wire_cst_list_prim_u_8_strict,
14240 }
14241 #[repr(C)]
14242 #[derive(Clone, Copy)]
14243 pub struct wire_cst_aes_success_action_data_result {
14244 tag: i32,
14245 kind: AesSuccessActionDataResultKind,
14246 }
14247 #[repr(C)]
14248 #[derive(Clone, Copy)]
14249 pub union AesSuccessActionDataResultKind {
14250 Decrypted: wire_cst_AesSuccessActionDataResult_Decrypted,
14251 ErrorStatus: wire_cst_AesSuccessActionDataResult_ErrorStatus,
14252 nil__: (),
14253 }
14254 #[repr(C)]
14255 #[derive(Clone, Copy)]
14256 pub struct wire_cst_AesSuccessActionDataResult_Decrypted {
14257 data: *mut wire_cst_aes_success_action_data_decrypted,
14258 }
14259 #[repr(C)]
14260 #[derive(Clone, Copy)]
14261 pub struct wire_cst_AesSuccessActionDataResult_ErrorStatus {
14262 reason: *mut wire_cst_list_prim_u_8_strict,
14263 }
14264 #[repr(C)]
14265 #[derive(Clone, Copy)]
14266 pub struct wire_cst_amount {
14267 tag: i32,
14268 kind: AmountKind,
14269 }
14270 #[repr(C)]
14271 #[derive(Clone, Copy)]
14272 pub union AmountKind {
14273 Bitcoin: wire_cst_Amount_Bitcoin,
14274 Currency: wire_cst_Amount_Currency,
14275 nil__: (),
14276 }
14277 #[repr(C)]
14278 #[derive(Clone, Copy)]
14279 pub struct wire_cst_Amount_Bitcoin {
14280 amount_msat: u64,
14281 }
14282 #[repr(C)]
14283 #[derive(Clone, Copy)]
14284 pub struct wire_cst_Amount_Currency {
14285 iso4217_code: *mut wire_cst_list_prim_u_8_strict,
14286 fractional_amount: u64,
14287 }
14288 #[repr(C)]
14289 #[derive(Clone, Copy)]
14290 pub struct wire_cst_asset_balance {
14291 asset_id: *mut wire_cst_list_prim_u_8_strict,
14292 balance_sat: u64,
14293 name: *mut wire_cst_list_prim_u_8_strict,
14294 ticker: *mut wire_cst_list_prim_u_8_strict,
14295 balance: *mut f64,
14296 }
14297 #[repr(C)]
14298 #[derive(Clone, Copy)]
14299 pub struct wire_cst_asset_info {
14300 name: *mut wire_cst_list_prim_u_8_strict,
14301 ticker: *mut wire_cst_list_prim_u_8_strict,
14302 amount: f64,
14303 fees: *mut f64,
14304 }
14305 #[repr(C)]
14306 #[derive(Clone, Copy)]
14307 pub struct wire_cst_asset_metadata {
14308 asset_id: *mut wire_cst_list_prim_u_8_strict,
14309 name: *mut wire_cst_list_prim_u_8_strict,
14310 ticker: *mut wire_cst_list_prim_u_8_strict,
14311 precision: u8,
14312 fiat_id: *mut wire_cst_list_prim_u_8_strict,
14313 }
14314 #[repr(C)]
14315 #[derive(Clone, Copy)]
14316 pub struct wire_cst_backup_request {
14317 backup_path: *mut wire_cst_list_prim_u_8_strict,
14318 }
14319 #[repr(C)]
14320 #[derive(Clone, Copy)]
14321 pub struct wire_cst_binding_event_listener {
14322 stream: *mut wire_cst_list_prim_u_8_strict,
14323 }
14324 #[repr(C)]
14325 #[derive(Clone, Copy)]
14326 pub struct wire_cst_bitcoin_address_data {
14327 address: *mut wire_cst_list_prim_u_8_strict,
14328 network: i32,
14329 amount_sat: *mut u64,
14330 label: *mut wire_cst_list_prim_u_8_strict,
14331 message: *mut wire_cst_list_prim_u_8_strict,
14332 }
14333 #[repr(C)]
14334 #[derive(Clone, Copy)]
14335 pub struct wire_cst_blockchain_explorer {
14336 tag: i32,
14337 kind: BlockchainExplorerKind,
14338 }
14339 #[repr(C)]
14340 #[derive(Clone, Copy)]
14341 pub union BlockchainExplorerKind {
14342 Electrum: wire_cst_BlockchainExplorer_Electrum,
14343 Esplora: wire_cst_BlockchainExplorer_Esplora,
14344 nil__: (),
14345 }
14346 #[repr(C)]
14347 #[derive(Clone, Copy)]
14348 pub struct wire_cst_BlockchainExplorer_Electrum {
14349 url: *mut wire_cst_list_prim_u_8_strict,
14350 }
14351 #[repr(C)]
14352 #[derive(Clone, Copy)]
14353 pub struct wire_cst_BlockchainExplorer_Esplora {
14354 url: *mut wire_cst_list_prim_u_8_strict,
14355 use_waterfalls: bool,
14356 }
14357 #[repr(C)]
14358 #[derive(Clone, Copy)]
14359 pub struct wire_cst_blockchain_info {
14360 liquid_tip: u32,
14361 bitcoin_tip: u32,
14362 }
14363 #[repr(C)]
14364 #[derive(Clone, Copy)]
14365 pub struct wire_cst_buy_bitcoin_request {
14366 prepare_response: wire_cst_prepare_buy_bitcoin_response,
14367 redirect_url: *mut wire_cst_list_prim_u_8_strict,
14368 }
14369 #[repr(C)]
14370 #[derive(Clone, Copy)]
14371 pub struct wire_cst_check_message_request {
14372 message: *mut wire_cst_list_prim_u_8_strict,
14373 pubkey: *mut wire_cst_list_prim_u_8_strict,
14374 signature: *mut wire_cst_list_prim_u_8_strict,
14375 }
14376 #[repr(C)]
14377 #[derive(Clone, Copy)]
14378 pub struct wire_cst_check_message_response {
14379 is_valid: bool,
14380 }
14381 #[repr(C)]
14382 #[derive(Clone, Copy)]
14383 pub struct wire_cst_config {
14384 liquid_explorer: wire_cst_blockchain_explorer,
14385 bitcoin_explorer: wire_cst_blockchain_explorer,
14386 working_dir: *mut wire_cst_list_prim_u_8_strict,
14387 network: i32,
14388 payment_timeout_sec: u64,
14389 sync_service_url: *mut wire_cst_list_prim_u_8_strict,
14390 zero_conf_max_amount_sat: *mut u64,
14391 breez_api_key: *mut wire_cst_list_prim_u_8_strict,
14392 external_input_parsers: *mut wire_cst_list_external_input_parser,
14393 use_default_external_input_parsers: bool,
14394 onchain_fee_rate_leeway_sat: *mut u64,
14395 asset_metadata: *mut wire_cst_list_asset_metadata,
14396 sideswap_api_key: *mut wire_cst_list_prim_u_8_strict,
14397 use_magic_routing_hints: bool,
14398 }
14399 #[repr(C)]
14400 #[derive(Clone, Copy)]
14401 pub struct wire_cst_connect_request {
14402 config: wire_cst_config,
14403 mnemonic: *mut wire_cst_list_prim_u_8_strict,
14404 passphrase: *mut wire_cst_list_prim_u_8_strict,
14405 seed: *mut wire_cst_list_prim_u_8_strict,
14406 }
14407 #[repr(C)]
14408 #[derive(Clone, Copy)]
14409 pub struct wire_cst_create_bolt_12_invoice_request {
14410 offer: *mut wire_cst_list_prim_u_8_strict,
14411 invoice_request: *mut wire_cst_list_prim_u_8_strict,
14412 }
14413 #[repr(C)]
14414 #[derive(Clone, Copy)]
14415 pub struct wire_cst_create_bolt_12_invoice_response {
14416 invoice: *mut wire_cst_list_prim_u_8_strict,
14417 }
14418 #[repr(C)]
14419 #[derive(Clone, Copy)]
14420 pub struct wire_cst_currency_info {
14421 name: *mut wire_cst_list_prim_u_8_strict,
14422 fraction_size: u32,
14423 spacing: *mut u32,
14424 symbol: *mut wire_cst_symbol,
14425 uniq_symbol: *mut wire_cst_symbol,
14426 localized_name: *mut wire_cst_list_localized_name,
14427 locale_overrides: *mut wire_cst_list_locale_overrides,
14428 }
14429 #[repr(C)]
14430 #[derive(Clone, Copy)]
14431 pub struct wire_cst_external_input_parser {
14432 provider_id: *mut wire_cst_list_prim_u_8_strict,
14433 input_regex: *mut wire_cst_list_prim_u_8_strict,
14434 parser_url: *mut wire_cst_list_prim_u_8_strict,
14435 }
14436 #[repr(C)]
14437 #[derive(Clone, Copy)]
14438 pub struct wire_cst_fetch_payment_proposed_fees_request {
14439 swap_id: *mut wire_cst_list_prim_u_8_strict,
14440 }
14441 #[repr(C)]
14442 #[derive(Clone, Copy)]
14443 pub struct wire_cst_fetch_payment_proposed_fees_response {
14444 swap_id: *mut wire_cst_list_prim_u_8_strict,
14445 fees_sat: u64,
14446 payer_amount_sat: u64,
14447 receiver_amount_sat: u64,
14448 }
14449 #[repr(C)]
14450 #[derive(Clone, Copy)]
14451 pub struct wire_cst_fiat_currency {
14452 id: *mut wire_cst_list_prim_u_8_strict,
14453 info: wire_cst_currency_info,
14454 }
14455 #[repr(C)]
14456 #[derive(Clone, Copy)]
14457 pub struct wire_cst_get_info_response {
14458 wallet_info: wire_cst_wallet_info,
14459 blockchain_info: wire_cst_blockchain_info,
14460 }
14461 #[repr(C)]
14462 #[derive(Clone, Copy)]
14463 pub struct wire_cst_get_payment_request {
14464 tag: i32,
14465 kind: GetPaymentRequestKind,
14466 }
14467 #[repr(C)]
14468 #[derive(Clone, Copy)]
14469 pub union GetPaymentRequestKind {
14470 PaymentHash: wire_cst_GetPaymentRequest_PaymentHash,
14471 SwapId: wire_cst_GetPaymentRequest_SwapId,
14472 nil__: (),
14473 }
14474 #[repr(C)]
14475 #[derive(Clone, Copy)]
14476 pub struct wire_cst_GetPaymentRequest_PaymentHash {
14477 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14478 }
14479 #[repr(C)]
14480 #[derive(Clone, Copy)]
14481 pub struct wire_cst_GetPaymentRequest_SwapId {
14482 swap_id: *mut wire_cst_list_prim_u_8_strict,
14483 }
14484 #[repr(C)]
14485 #[derive(Clone, Copy)]
14486 pub struct wire_cst_input_type {
14487 tag: i32,
14488 kind: InputTypeKind,
14489 }
14490 #[repr(C)]
14491 #[derive(Clone, Copy)]
14492 pub union InputTypeKind {
14493 BitcoinAddress: wire_cst_InputType_BitcoinAddress,
14494 LiquidAddress: wire_cst_InputType_LiquidAddress,
14495 Bolt11: wire_cst_InputType_Bolt11,
14496 Bolt12Offer: wire_cst_InputType_Bolt12Offer,
14497 NodeId: wire_cst_InputType_NodeId,
14498 Url: wire_cst_InputType_Url,
14499 LnUrlPay: wire_cst_InputType_LnUrlPay,
14500 LnUrlWithdraw: wire_cst_InputType_LnUrlWithdraw,
14501 LnUrlAuth: wire_cst_InputType_LnUrlAuth,
14502 LnUrlError: wire_cst_InputType_LnUrlError,
14503 nil__: (),
14504 }
14505 #[repr(C)]
14506 #[derive(Clone, Copy)]
14507 pub struct wire_cst_InputType_BitcoinAddress {
14508 address: *mut wire_cst_bitcoin_address_data,
14509 }
14510 #[repr(C)]
14511 #[derive(Clone, Copy)]
14512 pub struct wire_cst_InputType_LiquidAddress {
14513 address: *mut wire_cst_liquid_address_data,
14514 }
14515 #[repr(C)]
14516 #[derive(Clone, Copy)]
14517 pub struct wire_cst_InputType_Bolt11 {
14518 invoice: *mut wire_cst_ln_invoice,
14519 }
14520 #[repr(C)]
14521 #[derive(Clone, Copy)]
14522 pub struct wire_cst_InputType_Bolt12Offer {
14523 offer: *mut wire_cst_ln_offer,
14524 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14525 }
14526 #[repr(C)]
14527 #[derive(Clone, Copy)]
14528 pub struct wire_cst_InputType_NodeId {
14529 node_id: *mut wire_cst_list_prim_u_8_strict,
14530 }
14531 #[repr(C)]
14532 #[derive(Clone, Copy)]
14533 pub struct wire_cst_InputType_Url {
14534 url: *mut wire_cst_list_prim_u_8_strict,
14535 }
14536 #[repr(C)]
14537 #[derive(Clone, Copy)]
14538 pub struct wire_cst_InputType_LnUrlPay {
14539 data: *mut wire_cst_ln_url_pay_request_data,
14540 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14541 }
14542 #[repr(C)]
14543 #[derive(Clone, Copy)]
14544 pub struct wire_cst_InputType_LnUrlWithdraw {
14545 data: *mut wire_cst_ln_url_withdraw_request_data,
14546 }
14547 #[repr(C)]
14548 #[derive(Clone, Copy)]
14549 pub struct wire_cst_InputType_LnUrlAuth {
14550 data: *mut wire_cst_ln_url_auth_request_data,
14551 }
14552 #[repr(C)]
14553 #[derive(Clone, Copy)]
14554 pub struct wire_cst_InputType_LnUrlError {
14555 data: *mut wire_cst_ln_url_error_data,
14556 }
14557 #[repr(C)]
14558 #[derive(Clone, Copy)]
14559 pub struct wire_cst_lightning_payment_limits_response {
14560 send: wire_cst_limits,
14561 receive: wire_cst_limits,
14562 }
14563 #[repr(C)]
14564 #[derive(Clone, Copy)]
14565 pub struct wire_cst_limits {
14566 min_sat: u64,
14567 max_sat: u64,
14568 max_zero_conf_sat: u64,
14569 }
14570 #[repr(C)]
14571 #[derive(Clone, Copy)]
14572 pub struct wire_cst_liquid_address_data {
14573 address: *mut wire_cst_list_prim_u_8_strict,
14574 network: i32,
14575 asset_id: *mut wire_cst_list_prim_u_8_strict,
14576 amount: *mut f64,
14577 amount_sat: *mut u64,
14578 label: *mut wire_cst_list_prim_u_8_strict,
14579 message: *mut wire_cst_list_prim_u_8_strict,
14580 }
14581 #[repr(C)]
14582 #[derive(Clone, Copy)]
14583 pub struct wire_cst_list_String {
14584 ptr: *mut *mut wire_cst_list_prim_u_8_strict,
14585 len: i32,
14586 }
14587 #[repr(C)]
14588 #[derive(Clone, Copy)]
14589 pub struct wire_cst_list_asset_balance {
14590 ptr: *mut wire_cst_asset_balance,
14591 len: i32,
14592 }
14593 #[repr(C)]
14594 #[derive(Clone, Copy)]
14595 pub struct wire_cst_list_asset_metadata {
14596 ptr: *mut wire_cst_asset_metadata,
14597 len: i32,
14598 }
14599 #[repr(C)]
14600 #[derive(Clone, Copy)]
14601 pub struct wire_cst_list_external_input_parser {
14602 ptr: *mut wire_cst_external_input_parser,
14603 len: i32,
14604 }
14605 #[repr(C)]
14606 #[derive(Clone, Copy)]
14607 pub struct wire_cst_list_fiat_currency {
14608 ptr: *mut wire_cst_fiat_currency,
14609 len: i32,
14610 }
14611 #[repr(C)]
14612 #[derive(Clone, Copy)]
14613 pub struct wire_cst_list_ln_offer_blinded_path {
14614 ptr: *mut wire_cst_ln_offer_blinded_path,
14615 len: i32,
14616 }
14617 #[repr(C)]
14618 #[derive(Clone, Copy)]
14619 pub struct wire_cst_list_locale_overrides {
14620 ptr: *mut wire_cst_locale_overrides,
14621 len: i32,
14622 }
14623 #[repr(C)]
14624 #[derive(Clone, Copy)]
14625 pub struct wire_cst_list_localized_name {
14626 ptr: *mut wire_cst_localized_name,
14627 len: i32,
14628 }
14629 #[repr(C)]
14630 #[derive(Clone, Copy)]
14631 pub struct wire_cst_list_payment {
14632 ptr: *mut wire_cst_payment,
14633 len: i32,
14634 }
14635 #[repr(C)]
14636 #[derive(Clone, Copy)]
14637 pub struct wire_cst_list_payment_details {
14638 tag: i32,
14639 kind: ListPaymentDetailsKind,
14640 }
14641 #[repr(C)]
14642 #[derive(Clone, Copy)]
14643 pub union ListPaymentDetailsKind {
14644 Liquid: wire_cst_ListPaymentDetails_Liquid,
14645 Bitcoin: wire_cst_ListPaymentDetails_Bitcoin,
14646 nil__: (),
14647 }
14648 #[repr(C)]
14649 #[derive(Clone, Copy)]
14650 pub struct wire_cst_ListPaymentDetails_Liquid {
14651 asset_id: *mut wire_cst_list_prim_u_8_strict,
14652 destination: *mut wire_cst_list_prim_u_8_strict,
14653 }
14654 #[repr(C)]
14655 #[derive(Clone, Copy)]
14656 pub struct wire_cst_ListPaymentDetails_Bitcoin {
14657 address: *mut wire_cst_list_prim_u_8_strict,
14658 }
14659 #[repr(C)]
14660 #[derive(Clone, Copy)]
14661 pub struct wire_cst_list_payment_state {
14662 ptr: *mut i32,
14663 len: i32,
14664 }
14665 #[repr(C)]
14666 #[derive(Clone, Copy)]
14667 pub struct wire_cst_list_payment_type {
14668 ptr: *mut i32,
14669 len: i32,
14670 }
14671 #[repr(C)]
14672 #[derive(Clone, Copy)]
14673 pub struct wire_cst_list_payments_request {
14674 filters: *mut wire_cst_list_payment_type,
14675 states: *mut wire_cst_list_payment_state,
14676 from_timestamp: *mut i64,
14677 to_timestamp: *mut i64,
14678 offset: *mut u32,
14679 limit: *mut u32,
14680 details: *mut wire_cst_list_payment_details,
14681 sort_ascending: *mut bool,
14682 }
14683 #[repr(C)]
14684 #[derive(Clone, Copy)]
14685 pub struct wire_cst_list_prim_u_8_strict {
14686 ptr: *mut u8,
14687 len: i32,
14688 }
14689 #[repr(C)]
14690 #[derive(Clone, Copy)]
14691 pub struct wire_cst_list_rate {
14692 ptr: *mut wire_cst_rate,
14693 len: i32,
14694 }
14695 #[repr(C)]
14696 #[derive(Clone, Copy)]
14697 pub struct wire_cst_list_refundable_swap {
14698 ptr: *mut wire_cst_refundable_swap,
14699 len: i32,
14700 }
14701 #[repr(C)]
14702 #[derive(Clone, Copy)]
14703 pub struct wire_cst_list_route_hint {
14704 ptr: *mut wire_cst_route_hint,
14705 len: i32,
14706 }
14707 #[repr(C)]
14708 #[derive(Clone, Copy)]
14709 pub struct wire_cst_list_route_hint_hop {
14710 ptr: *mut wire_cst_route_hint_hop,
14711 len: i32,
14712 }
14713 #[repr(C)]
14714 #[derive(Clone, Copy)]
14715 pub struct wire_cst_ln_invoice {
14716 bolt11: *mut wire_cst_list_prim_u_8_strict,
14717 network: i32,
14718 payee_pubkey: *mut wire_cst_list_prim_u_8_strict,
14719 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14720 description: *mut wire_cst_list_prim_u_8_strict,
14721 description_hash: *mut wire_cst_list_prim_u_8_strict,
14722 amount_msat: *mut u64,
14723 timestamp: u64,
14724 expiry: u64,
14725 routing_hints: *mut wire_cst_list_route_hint,
14726 payment_secret: *mut wire_cst_list_prim_u_8_strict,
14727 min_final_cltv_expiry_delta: u64,
14728 }
14729 #[repr(C)]
14730 #[derive(Clone, Copy)]
14731 pub struct wire_cst_ln_offer {
14732 offer: *mut wire_cst_list_prim_u_8_strict,
14733 chains: *mut wire_cst_list_String,
14734 min_amount: *mut wire_cst_amount,
14735 description: *mut wire_cst_list_prim_u_8_strict,
14736 absolute_expiry: *mut u64,
14737 issuer: *mut wire_cst_list_prim_u_8_strict,
14738 signing_pubkey: *mut wire_cst_list_prim_u_8_strict,
14739 paths: *mut wire_cst_list_ln_offer_blinded_path,
14740 }
14741 #[repr(C)]
14742 #[derive(Clone, Copy)]
14743 pub struct wire_cst_ln_offer_blinded_path {
14744 blinded_hops: *mut wire_cst_list_String,
14745 }
14746 #[repr(C)]
14747 #[derive(Clone, Copy)]
14748 pub struct wire_cst_ln_url_auth_error {
14749 tag: i32,
14750 kind: LnUrlAuthErrorKind,
14751 }
14752 #[repr(C)]
14753 #[derive(Clone, Copy)]
14754 pub union LnUrlAuthErrorKind {
14755 Generic: wire_cst_LnUrlAuthError_Generic,
14756 InvalidUri: wire_cst_LnUrlAuthError_InvalidUri,
14757 ServiceConnectivity: wire_cst_LnUrlAuthError_ServiceConnectivity,
14758 nil__: (),
14759 }
14760 #[repr(C)]
14761 #[derive(Clone, Copy)]
14762 pub struct wire_cst_LnUrlAuthError_Generic {
14763 err: *mut wire_cst_list_prim_u_8_strict,
14764 }
14765 #[repr(C)]
14766 #[derive(Clone, Copy)]
14767 pub struct wire_cst_LnUrlAuthError_InvalidUri {
14768 err: *mut wire_cst_list_prim_u_8_strict,
14769 }
14770 #[repr(C)]
14771 #[derive(Clone, Copy)]
14772 pub struct wire_cst_LnUrlAuthError_ServiceConnectivity {
14773 err: *mut wire_cst_list_prim_u_8_strict,
14774 }
14775 #[repr(C)]
14776 #[derive(Clone, Copy)]
14777 pub struct wire_cst_ln_url_auth_request_data {
14778 k1: *mut wire_cst_list_prim_u_8_strict,
14779 action: *mut wire_cst_list_prim_u_8_strict,
14780 domain: *mut wire_cst_list_prim_u_8_strict,
14781 url: *mut wire_cst_list_prim_u_8_strict,
14782 }
14783 #[repr(C)]
14784 #[derive(Clone, Copy)]
14785 pub struct wire_cst_ln_url_callback_status {
14786 tag: i32,
14787 kind: LnUrlCallbackStatusKind,
14788 }
14789 #[repr(C)]
14790 #[derive(Clone, Copy)]
14791 pub union LnUrlCallbackStatusKind {
14792 ErrorStatus: wire_cst_LnUrlCallbackStatus_ErrorStatus,
14793 nil__: (),
14794 }
14795 #[repr(C)]
14796 #[derive(Clone, Copy)]
14797 pub struct wire_cst_LnUrlCallbackStatus_ErrorStatus {
14798 data: *mut wire_cst_ln_url_error_data,
14799 }
14800 #[repr(C)]
14801 #[derive(Clone, Copy)]
14802 pub struct wire_cst_ln_url_error_data {
14803 reason: *mut wire_cst_list_prim_u_8_strict,
14804 }
14805 #[repr(C)]
14806 #[derive(Clone, Copy)]
14807 pub struct wire_cst_ln_url_info {
14808 ln_address: *mut wire_cst_list_prim_u_8_strict,
14809 lnurl_pay_comment: *mut wire_cst_list_prim_u_8_strict,
14810 lnurl_pay_domain: *mut wire_cst_list_prim_u_8_strict,
14811 lnurl_pay_metadata: *mut wire_cst_list_prim_u_8_strict,
14812 lnurl_pay_success_action: *mut wire_cst_success_action_processed,
14813 lnurl_pay_unprocessed_success_action: *mut wire_cst_success_action,
14814 lnurl_withdraw_endpoint: *mut wire_cst_list_prim_u_8_strict,
14815 }
14816 #[repr(C)]
14817 #[derive(Clone, Copy)]
14818 pub struct wire_cst_ln_url_pay_error {
14819 tag: i32,
14820 kind: LnUrlPayErrorKind,
14821 }
14822 #[repr(C)]
14823 #[derive(Clone, Copy)]
14824 pub union LnUrlPayErrorKind {
14825 Generic: wire_cst_LnUrlPayError_Generic,
14826 InsufficientBalance: wire_cst_LnUrlPayError_InsufficientBalance,
14827 InvalidAmount: wire_cst_LnUrlPayError_InvalidAmount,
14828 InvalidInvoice: wire_cst_LnUrlPayError_InvalidInvoice,
14829 InvalidNetwork: wire_cst_LnUrlPayError_InvalidNetwork,
14830 InvalidUri: wire_cst_LnUrlPayError_InvalidUri,
14831 InvoiceExpired: wire_cst_LnUrlPayError_InvoiceExpired,
14832 PaymentFailed: wire_cst_LnUrlPayError_PaymentFailed,
14833 PaymentTimeout: wire_cst_LnUrlPayError_PaymentTimeout,
14834 RouteNotFound: wire_cst_LnUrlPayError_RouteNotFound,
14835 RouteTooExpensive: wire_cst_LnUrlPayError_RouteTooExpensive,
14836 ServiceConnectivity: wire_cst_LnUrlPayError_ServiceConnectivity,
14837 nil__: (),
14838 }
14839 #[repr(C)]
14840 #[derive(Clone, Copy)]
14841 pub struct wire_cst_LnUrlPayError_Generic {
14842 err: *mut wire_cst_list_prim_u_8_strict,
14843 }
14844 #[repr(C)]
14845 #[derive(Clone, Copy)]
14846 pub struct wire_cst_LnUrlPayError_InsufficientBalance {
14847 err: *mut wire_cst_list_prim_u_8_strict,
14848 }
14849 #[repr(C)]
14850 #[derive(Clone, Copy)]
14851 pub struct wire_cst_LnUrlPayError_InvalidAmount {
14852 err: *mut wire_cst_list_prim_u_8_strict,
14853 }
14854 #[repr(C)]
14855 #[derive(Clone, Copy)]
14856 pub struct wire_cst_LnUrlPayError_InvalidInvoice {
14857 err: *mut wire_cst_list_prim_u_8_strict,
14858 }
14859 #[repr(C)]
14860 #[derive(Clone, Copy)]
14861 pub struct wire_cst_LnUrlPayError_InvalidNetwork {
14862 err: *mut wire_cst_list_prim_u_8_strict,
14863 }
14864 #[repr(C)]
14865 #[derive(Clone, Copy)]
14866 pub struct wire_cst_LnUrlPayError_InvalidUri {
14867 err: *mut wire_cst_list_prim_u_8_strict,
14868 }
14869 #[repr(C)]
14870 #[derive(Clone, Copy)]
14871 pub struct wire_cst_LnUrlPayError_InvoiceExpired {
14872 err: *mut wire_cst_list_prim_u_8_strict,
14873 }
14874 #[repr(C)]
14875 #[derive(Clone, Copy)]
14876 pub struct wire_cst_LnUrlPayError_PaymentFailed {
14877 err: *mut wire_cst_list_prim_u_8_strict,
14878 }
14879 #[repr(C)]
14880 #[derive(Clone, Copy)]
14881 pub struct wire_cst_LnUrlPayError_PaymentTimeout {
14882 err: *mut wire_cst_list_prim_u_8_strict,
14883 }
14884 #[repr(C)]
14885 #[derive(Clone, Copy)]
14886 pub struct wire_cst_LnUrlPayError_RouteNotFound {
14887 err: *mut wire_cst_list_prim_u_8_strict,
14888 }
14889 #[repr(C)]
14890 #[derive(Clone, Copy)]
14891 pub struct wire_cst_LnUrlPayError_RouteTooExpensive {
14892 err: *mut wire_cst_list_prim_u_8_strict,
14893 }
14894 #[repr(C)]
14895 #[derive(Clone, Copy)]
14896 pub struct wire_cst_LnUrlPayError_ServiceConnectivity {
14897 err: *mut wire_cst_list_prim_u_8_strict,
14898 }
14899 #[repr(C)]
14900 #[derive(Clone, Copy)]
14901 pub struct wire_cst_ln_url_pay_error_data {
14902 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14903 reason: *mut wire_cst_list_prim_u_8_strict,
14904 }
14905 #[repr(C)]
14906 #[derive(Clone, Copy)]
14907 pub struct wire_cst_ln_url_pay_request {
14908 prepare_response: wire_cst_prepare_ln_url_pay_response,
14909 }
14910 #[repr(C)]
14911 #[derive(Clone, Copy)]
14912 pub struct wire_cst_ln_url_pay_request_data {
14913 callback: *mut wire_cst_list_prim_u_8_strict,
14914 min_sendable: u64,
14915 max_sendable: u64,
14916 metadata_str: *mut wire_cst_list_prim_u_8_strict,
14917 comment_allowed: u16,
14918 domain: *mut wire_cst_list_prim_u_8_strict,
14919 allows_nostr: bool,
14920 nostr_pubkey: *mut wire_cst_list_prim_u_8_strict,
14921 ln_address: *mut wire_cst_list_prim_u_8_strict,
14922 }
14923 #[repr(C)]
14924 #[derive(Clone, Copy)]
14925 pub struct wire_cst_ln_url_pay_result {
14926 tag: i32,
14927 kind: LnUrlPayResultKind,
14928 }
14929 #[repr(C)]
14930 #[derive(Clone, Copy)]
14931 pub union LnUrlPayResultKind {
14932 EndpointSuccess: wire_cst_LnUrlPayResult_EndpointSuccess,
14933 EndpointError: wire_cst_LnUrlPayResult_EndpointError,
14934 PayError: wire_cst_LnUrlPayResult_PayError,
14935 nil__: (),
14936 }
14937 #[repr(C)]
14938 #[derive(Clone, Copy)]
14939 pub struct wire_cst_LnUrlPayResult_EndpointSuccess {
14940 data: *mut wire_cst_ln_url_pay_success_data,
14941 }
14942 #[repr(C)]
14943 #[derive(Clone, Copy)]
14944 pub struct wire_cst_LnUrlPayResult_EndpointError {
14945 data: *mut wire_cst_ln_url_error_data,
14946 }
14947 #[repr(C)]
14948 #[derive(Clone, Copy)]
14949 pub struct wire_cst_LnUrlPayResult_PayError {
14950 data: *mut wire_cst_ln_url_pay_error_data,
14951 }
14952 #[repr(C)]
14953 #[derive(Clone, Copy)]
14954 pub struct wire_cst_ln_url_pay_success_data {
14955 payment: wire_cst_payment,
14956 success_action: *mut wire_cst_success_action_processed,
14957 }
14958 #[repr(C)]
14959 #[derive(Clone, Copy)]
14960 pub struct wire_cst_ln_url_withdraw_error {
14961 tag: i32,
14962 kind: LnUrlWithdrawErrorKind,
14963 }
14964 #[repr(C)]
14965 #[derive(Clone, Copy)]
14966 pub union LnUrlWithdrawErrorKind {
14967 Generic: wire_cst_LnUrlWithdrawError_Generic,
14968 InvalidAmount: wire_cst_LnUrlWithdrawError_InvalidAmount,
14969 InvalidInvoice: wire_cst_LnUrlWithdrawError_InvalidInvoice,
14970 InvalidUri: wire_cst_LnUrlWithdrawError_InvalidUri,
14971 InvoiceNoRoutingHints: wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints,
14972 ServiceConnectivity: wire_cst_LnUrlWithdrawError_ServiceConnectivity,
14973 nil__: (),
14974 }
14975 #[repr(C)]
14976 #[derive(Clone, Copy)]
14977 pub struct wire_cst_LnUrlWithdrawError_Generic {
14978 err: *mut wire_cst_list_prim_u_8_strict,
14979 }
14980 #[repr(C)]
14981 #[derive(Clone, Copy)]
14982 pub struct wire_cst_LnUrlWithdrawError_InvalidAmount {
14983 err: *mut wire_cst_list_prim_u_8_strict,
14984 }
14985 #[repr(C)]
14986 #[derive(Clone, Copy)]
14987 pub struct wire_cst_LnUrlWithdrawError_InvalidInvoice {
14988 err: *mut wire_cst_list_prim_u_8_strict,
14989 }
14990 #[repr(C)]
14991 #[derive(Clone, Copy)]
14992 pub struct wire_cst_LnUrlWithdrawError_InvalidUri {
14993 err: *mut wire_cst_list_prim_u_8_strict,
14994 }
14995 #[repr(C)]
14996 #[derive(Clone, Copy)]
14997 pub struct wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints {
14998 err: *mut wire_cst_list_prim_u_8_strict,
14999 }
15000 #[repr(C)]
15001 #[derive(Clone, Copy)]
15002 pub struct wire_cst_LnUrlWithdrawError_ServiceConnectivity {
15003 err: *mut wire_cst_list_prim_u_8_strict,
15004 }
15005 #[repr(C)]
15006 #[derive(Clone, Copy)]
15007 pub struct wire_cst_ln_url_withdraw_request {
15008 data: wire_cst_ln_url_withdraw_request_data,
15009 amount_msat: u64,
15010 description: *mut wire_cst_list_prim_u_8_strict,
15011 }
15012 #[repr(C)]
15013 #[derive(Clone, Copy)]
15014 pub struct wire_cst_ln_url_withdraw_request_data {
15015 callback: *mut wire_cst_list_prim_u_8_strict,
15016 k1: *mut wire_cst_list_prim_u_8_strict,
15017 default_description: *mut wire_cst_list_prim_u_8_strict,
15018 min_withdrawable: u64,
15019 max_withdrawable: u64,
15020 }
15021 #[repr(C)]
15022 #[derive(Clone, Copy)]
15023 pub struct wire_cst_ln_url_withdraw_result {
15024 tag: i32,
15025 kind: LnUrlWithdrawResultKind,
15026 }
15027 #[repr(C)]
15028 #[derive(Clone, Copy)]
15029 pub union LnUrlWithdrawResultKind {
15030 Ok: wire_cst_LnUrlWithdrawResult_Ok,
15031 Timeout: wire_cst_LnUrlWithdrawResult_Timeout,
15032 ErrorStatus: wire_cst_LnUrlWithdrawResult_ErrorStatus,
15033 nil__: (),
15034 }
15035 #[repr(C)]
15036 #[derive(Clone, Copy)]
15037 pub struct wire_cst_LnUrlWithdrawResult_Ok {
15038 data: *mut wire_cst_ln_url_withdraw_success_data,
15039 }
15040 #[repr(C)]
15041 #[derive(Clone, Copy)]
15042 pub struct wire_cst_LnUrlWithdrawResult_Timeout {
15043 data: *mut wire_cst_ln_url_withdraw_success_data,
15044 }
15045 #[repr(C)]
15046 #[derive(Clone, Copy)]
15047 pub struct wire_cst_LnUrlWithdrawResult_ErrorStatus {
15048 data: *mut wire_cst_ln_url_error_data,
15049 }
15050 #[repr(C)]
15051 #[derive(Clone, Copy)]
15052 pub struct wire_cst_ln_url_withdraw_success_data {
15053 invoice: wire_cst_ln_invoice,
15054 }
15055 #[repr(C)]
15056 #[derive(Clone, Copy)]
15057 pub struct wire_cst_locale_overrides {
15058 locale: *mut wire_cst_list_prim_u_8_strict,
15059 spacing: *mut u32,
15060 symbol: wire_cst_symbol,
15061 }
15062 #[repr(C)]
15063 #[derive(Clone, Copy)]
15064 pub struct wire_cst_localized_name {
15065 locale: *mut wire_cst_list_prim_u_8_strict,
15066 name: *mut wire_cst_list_prim_u_8_strict,
15067 }
15068 #[repr(C)]
15069 #[derive(Clone, Copy)]
15070 pub struct wire_cst_log_entry {
15071 line: *mut wire_cst_list_prim_u_8_strict,
15072 level: *mut wire_cst_list_prim_u_8_strict,
15073 }
15074 #[repr(C)]
15075 #[derive(Clone, Copy)]
15076 pub struct wire_cst_message_success_action_data {
15077 message: *mut wire_cst_list_prim_u_8_strict,
15078 }
15079 #[repr(C)]
15080 #[derive(Clone, Copy)]
15081 pub struct wire_cst_onchain_payment_limits_response {
15082 send: wire_cst_limits,
15083 receive: wire_cst_limits,
15084 }
15085 #[repr(C)]
15086 #[derive(Clone, Copy)]
15087 pub struct wire_cst_pay_amount {
15088 tag: i32,
15089 kind: PayAmountKind,
15090 }
15091 #[repr(C)]
15092 #[derive(Clone, Copy)]
15093 pub union PayAmountKind {
15094 Bitcoin: wire_cst_PayAmount_Bitcoin,
15095 Asset: wire_cst_PayAmount_Asset,
15096 nil__: (),
15097 }
15098 #[repr(C)]
15099 #[derive(Clone, Copy)]
15100 pub struct wire_cst_PayAmount_Bitcoin {
15101 receiver_amount_sat: u64,
15102 }
15103 #[repr(C)]
15104 #[derive(Clone, Copy)]
15105 pub struct wire_cst_PayAmount_Asset {
15106 to_asset: *mut wire_cst_list_prim_u_8_strict,
15107 receiver_amount: f64,
15108 estimate_asset_fees: *mut bool,
15109 from_asset: *mut wire_cst_list_prim_u_8_strict,
15110 }
15111 #[repr(C)]
15112 #[derive(Clone, Copy)]
15113 pub struct wire_cst_pay_onchain_request {
15114 address: *mut wire_cst_list_prim_u_8_strict,
15115 prepare_response: wire_cst_prepare_pay_onchain_response,
15116 }
15117 #[repr(C)]
15118 #[derive(Clone, Copy)]
15119 pub struct wire_cst_payment {
15120 destination: *mut wire_cst_list_prim_u_8_strict,
15121 tx_id: *mut wire_cst_list_prim_u_8_strict,
15122 unblinding_data: *mut wire_cst_list_prim_u_8_strict,
15123 timestamp: u32,
15124 amount_sat: u64,
15125 fees_sat: u64,
15126 swapper_fees_sat: *mut u64,
15127 payment_type: i32,
15128 status: i32,
15129 details: wire_cst_payment_details,
15130 }
15131 #[repr(C)]
15132 #[derive(Clone, Copy)]
15133 pub struct wire_cst_payment_details {
15134 tag: i32,
15135 kind: PaymentDetailsKind,
15136 }
15137 #[repr(C)]
15138 #[derive(Clone, Copy)]
15139 pub union PaymentDetailsKind {
15140 Lightning: wire_cst_PaymentDetails_Lightning,
15141 Liquid: wire_cst_PaymentDetails_Liquid,
15142 Bitcoin: wire_cst_PaymentDetails_Bitcoin,
15143 nil__: (),
15144 }
15145 #[repr(C)]
15146 #[derive(Clone, Copy)]
15147 pub struct wire_cst_PaymentDetails_Lightning {
15148 swap_id: *mut wire_cst_list_prim_u_8_strict,
15149 description: *mut wire_cst_list_prim_u_8_strict,
15150 liquid_expiration_blockheight: u32,
15151 preimage: *mut wire_cst_list_prim_u_8_strict,
15152 invoice: *mut wire_cst_list_prim_u_8_strict,
15153 bolt12_offer: *mut wire_cst_list_prim_u_8_strict,
15154 payment_hash: *mut wire_cst_list_prim_u_8_strict,
15155 destination_pubkey: *mut wire_cst_list_prim_u_8_strict,
15156 lnurl_info: *mut wire_cst_ln_url_info,
15157 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15158 payer_note: *mut wire_cst_list_prim_u_8_strict,
15159 claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15160 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15161 refund_tx_amount_sat: *mut u64,
15162 }
15163 #[repr(C)]
15164 #[derive(Clone, Copy)]
15165 pub struct wire_cst_PaymentDetails_Liquid {
15166 destination: *mut wire_cst_list_prim_u_8_strict,
15167 description: *mut wire_cst_list_prim_u_8_strict,
15168 asset_id: *mut wire_cst_list_prim_u_8_strict,
15169 asset_info: *mut wire_cst_asset_info,
15170 lnurl_info: *mut wire_cst_ln_url_info,
15171 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15172 payer_note: *mut wire_cst_list_prim_u_8_strict,
15173 }
15174 #[repr(C)]
15175 #[derive(Clone, Copy)]
15176 pub struct wire_cst_PaymentDetails_Bitcoin {
15177 swap_id: *mut wire_cst_list_prim_u_8_strict,
15178 bitcoin_address: *mut wire_cst_list_prim_u_8_strict,
15179 description: *mut wire_cst_list_prim_u_8_strict,
15180 auto_accepted_fees: bool,
15181 liquid_expiration_blockheight: u32,
15182 bitcoin_expiration_blockheight: u32,
15183 lockup_tx_id: *mut wire_cst_list_prim_u_8_strict,
15184 claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15185 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15186 refund_tx_amount_sat: *mut u64,
15187 }
15188 #[repr(C)]
15189 #[derive(Clone, Copy)]
15190 pub struct wire_cst_payment_error {
15191 tag: i32,
15192 kind: PaymentErrorKind,
15193 }
15194 #[repr(C)]
15195 #[derive(Clone, Copy)]
15196 pub union PaymentErrorKind {
15197 AmountOutOfRange: wire_cst_PaymentError_AmountOutOfRange,
15198 AmountMissing: wire_cst_PaymentError_AmountMissing,
15199 AssetError: wire_cst_PaymentError_AssetError,
15200 InvalidNetwork: wire_cst_PaymentError_InvalidNetwork,
15201 Generic: wire_cst_PaymentError_Generic,
15202 InvalidDescription: wire_cst_PaymentError_InvalidDescription,
15203 InvalidInvoice: wire_cst_PaymentError_InvalidInvoice,
15204 ReceiveError: wire_cst_PaymentError_ReceiveError,
15205 Refunded: wire_cst_PaymentError_Refunded,
15206 SendError: wire_cst_PaymentError_SendError,
15207 SignerError: wire_cst_PaymentError_SignerError,
15208 nil__: (),
15209 }
15210 #[repr(C)]
15211 #[derive(Clone, Copy)]
15212 pub struct wire_cst_PaymentError_AmountOutOfRange {
15213 min: u64,
15214 max: u64,
15215 }
15216 #[repr(C)]
15217 #[derive(Clone, Copy)]
15218 pub struct wire_cst_PaymentError_AmountMissing {
15219 err: *mut wire_cst_list_prim_u_8_strict,
15220 }
15221 #[repr(C)]
15222 #[derive(Clone, Copy)]
15223 pub struct wire_cst_PaymentError_AssetError {
15224 err: *mut wire_cst_list_prim_u_8_strict,
15225 }
15226 #[repr(C)]
15227 #[derive(Clone, Copy)]
15228 pub struct wire_cst_PaymentError_InvalidNetwork {
15229 err: *mut wire_cst_list_prim_u_8_strict,
15230 }
15231 #[repr(C)]
15232 #[derive(Clone, Copy)]
15233 pub struct wire_cst_PaymentError_Generic {
15234 err: *mut wire_cst_list_prim_u_8_strict,
15235 }
15236 #[repr(C)]
15237 #[derive(Clone, Copy)]
15238 pub struct wire_cst_PaymentError_InvalidDescription {
15239 err: *mut wire_cst_list_prim_u_8_strict,
15240 }
15241 #[repr(C)]
15242 #[derive(Clone, Copy)]
15243 pub struct wire_cst_PaymentError_InvalidInvoice {
15244 err: *mut wire_cst_list_prim_u_8_strict,
15245 }
15246 #[repr(C)]
15247 #[derive(Clone, Copy)]
15248 pub struct wire_cst_PaymentError_ReceiveError {
15249 err: *mut wire_cst_list_prim_u_8_strict,
15250 }
15251 #[repr(C)]
15252 #[derive(Clone, Copy)]
15253 pub struct wire_cst_PaymentError_Refunded {
15254 err: *mut wire_cst_list_prim_u_8_strict,
15255 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15256 }
15257 #[repr(C)]
15258 #[derive(Clone, Copy)]
15259 pub struct wire_cst_PaymentError_SendError {
15260 err: *mut wire_cst_list_prim_u_8_strict,
15261 }
15262 #[repr(C)]
15263 #[derive(Clone, Copy)]
15264 pub struct wire_cst_PaymentError_SignerError {
15265 err: *mut wire_cst_list_prim_u_8_strict,
15266 }
15267 #[repr(C)]
15268 #[derive(Clone, Copy)]
15269 pub struct wire_cst_prepare_buy_bitcoin_request {
15270 provider: i32,
15271 amount_sat: u64,
15272 }
15273 #[repr(C)]
15274 #[derive(Clone, Copy)]
15275 pub struct wire_cst_prepare_buy_bitcoin_response {
15276 provider: i32,
15277 amount_sat: u64,
15278 fees_sat: u64,
15279 }
15280 #[repr(C)]
15281 #[derive(Clone, Copy)]
15282 pub struct wire_cst_prepare_ln_url_pay_request {
15283 data: wire_cst_ln_url_pay_request_data,
15284 amount: wire_cst_pay_amount,
15285 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15286 comment: *mut wire_cst_list_prim_u_8_strict,
15287 validate_success_action_url: *mut bool,
15288 }
15289 #[repr(C)]
15290 #[derive(Clone, Copy)]
15291 pub struct wire_cst_prepare_ln_url_pay_response {
15292 destination: wire_cst_send_destination,
15293 fees_sat: u64,
15294 data: wire_cst_ln_url_pay_request_data,
15295 amount: wire_cst_pay_amount,
15296 comment: *mut wire_cst_list_prim_u_8_strict,
15297 success_action: *mut wire_cst_success_action,
15298 }
15299 #[repr(C)]
15300 #[derive(Clone, Copy)]
15301 pub struct wire_cst_prepare_pay_onchain_request {
15302 amount: wire_cst_pay_amount,
15303 fee_rate_sat_per_vbyte: *mut u32,
15304 }
15305 #[repr(C)]
15306 #[derive(Clone, Copy)]
15307 pub struct wire_cst_prepare_pay_onchain_response {
15308 receiver_amount_sat: u64,
15309 claim_fees_sat: u64,
15310 total_fees_sat: u64,
15311 }
15312 #[repr(C)]
15313 #[derive(Clone, Copy)]
15314 pub struct wire_cst_prepare_receive_request {
15315 payment_method: i32,
15316 amount: *mut wire_cst_receive_amount,
15317 }
15318 #[repr(C)]
15319 #[derive(Clone, Copy)]
15320 pub struct wire_cst_prepare_receive_response {
15321 payment_method: i32,
15322 fees_sat: u64,
15323 amount: *mut wire_cst_receive_amount,
15324 min_payer_amount_sat: *mut u64,
15325 max_payer_amount_sat: *mut u64,
15326 swapper_feerate: *mut f64,
15327 }
15328 #[repr(C)]
15329 #[derive(Clone, Copy)]
15330 pub struct wire_cst_prepare_refund_request {
15331 swap_address: *mut wire_cst_list_prim_u_8_strict,
15332 refund_address: *mut wire_cst_list_prim_u_8_strict,
15333 fee_rate_sat_per_vbyte: u32,
15334 }
15335 #[repr(C)]
15336 #[derive(Clone, Copy)]
15337 pub struct wire_cst_prepare_refund_response {
15338 tx_vsize: u32,
15339 tx_fee_sat: u64,
15340 last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15341 }
15342 #[repr(C)]
15343 #[derive(Clone, Copy)]
15344 pub struct wire_cst_prepare_send_request {
15345 destination: *mut wire_cst_list_prim_u_8_strict,
15346 amount: *mut wire_cst_pay_amount,
15347 }
15348 #[repr(C)]
15349 #[derive(Clone, Copy)]
15350 pub struct wire_cst_prepare_send_response {
15351 destination: wire_cst_send_destination,
15352 amount: *mut wire_cst_pay_amount,
15353 fees_sat: *mut u64,
15354 estimated_asset_fees: *mut f64,
15355 exchange_amount_sat: *mut u64,
15356 }
15357 #[repr(C)]
15358 #[derive(Clone, Copy)]
15359 pub struct wire_cst_rate {
15360 coin: *mut wire_cst_list_prim_u_8_strict,
15361 value: f64,
15362 }
15363 #[repr(C)]
15364 #[derive(Clone, Copy)]
15365 pub struct wire_cst_receive_amount {
15366 tag: i32,
15367 kind: ReceiveAmountKind,
15368 }
15369 #[repr(C)]
15370 #[derive(Clone, Copy)]
15371 pub union ReceiveAmountKind {
15372 Bitcoin: wire_cst_ReceiveAmount_Bitcoin,
15373 Asset: wire_cst_ReceiveAmount_Asset,
15374 nil__: (),
15375 }
15376 #[repr(C)]
15377 #[derive(Clone, Copy)]
15378 pub struct wire_cst_ReceiveAmount_Bitcoin {
15379 payer_amount_sat: u64,
15380 }
15381 #[repr(C)]
15382 #[derive(Clone, Copy)]
15383 pub struct wire_cst_ReceiveAmount_Asset {
15384 asset_id: *mut wire_cst_list_prim_u_8_strict,
15385 payer_amount: *mut f64,
15386 }
15387 #[repr(C)]
15388 #[derive(Clone, Copy)]
15389 pub struct wire_cst_receive_payment_request {
15390 prepare_response: wire_cst_prepare_receive_response,
15391 description: *mut wire_cst_list_prim_u_8_strict,
15392 use_description_hash: *mut bool,
15393 payer_note: *mut wire_cst_list_prim_u_8_strict,
15394 }
15395 #[repr(C)]
15396 #[derive(Clone, Copy)]
15397 pub struct wire_cst_receive_payment_response {
15398 destination: *mut wire_cst_list_prim_u_8_strict,
15399 liquid_expiration_blockheight: *mut u32,
15400 bitcoin_expiration_blockheight: *mut u32,
15401 }
15402 #[repr(C)]
15403 #[derive(Clone, Copy)]
15404 pub struct wire_cst_recommended_fees {
15405 fastest_fee: u64,
15406 half_hour_fee: u64,
15407 hour_fee: u64,
15408 economy_fee: u64,
15409 minimum_fee: u64,
15410 }
15411 #[repr(C)]
15412 #[derive(Clone, Copy)]
15413 pub struct wire_cst_refund_request {
15414 swap_address: *mut wire_cst_list_prim_u_8_strict,
15415 refund_address: *mut wire_cst_list_prim_u_8_strict,
15416 fee_rate_sat_per_vbyte: u32,
15417 }
15418 #[repr(C)]
15419 #[derive(Clone, Copy)]
15420 pub struct wire_cst_refund_response {
15421 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15422 }
15423 #[repr(C)]
15424 #[derive(Clone, Copy)]
15425 pub struct wire_cst_refundable_swap {
15426 swap_address: *mut wire_cst_list_prim_u_8_strict,
15427 timestamp: u32,
15428 amount_sat: u64,
15429 last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15430 }
15431 #[repr(C)]
15432 #[derive(Clone, Copy)]
15433 pub struct wire_cst_restore_request {
15434 backup_path: *mut wire_cst_list_prim_u_8_strict,
15435 }
15436 #[repr(C)]
15437 #[derive(Clone, Copy)]
15438 pub struct wire_cst_route_hint {
15439 hops: *mut wire_cst_list_route_hint_hop,
15440 }
15441 #[repr(C)]
15442 #[derive(Clone, Copy)]
15443 pub struct wire_cst_route_hint_hop {
15444 src_node_id: *mut wire_cst_list_prim_u_8_strict,
15445 short_channel_id: *mut wire_cst_list_prim_u_8_strict,
15446 fees_base_msat: u32,
15447 fees_proportional_millionths: u32,
15448 cltv_expiry_delta: u64,
15449 htlc_minimum_msat: *mut u64,
15450 htlc_maximum_msat: *mut u64,
15451 }
15452 #[repr(C)]
15453 #[derive(Clone, Copy)]
15454 pub struct wire_cst_sdk_error {
15455 tag: i32,
15456 kind: SdkErrorKind,
15457 }
15458 #[repr(C)]
15459 #[derive(Clone, Copy)]
15460 pub union SdkErrorKind {
15461 Generic: wire_cst_SdkError_Generic,
15462 ServiceConnectivity: wire_cst_SdkError_ServiceConnectivity,
15463 nil__: (),
15464 }
15465 #[repr(C)]
15466 #[derive(Clone, Copy)]
15467 pub struct wire_cst_SdkError_Generic {
15468 err: *mut wire_cst_list_prim_u_8_strict,
15469 }
15470 #[repr(C)]
15471 #[derive(Clone, Copy)]
15472 pub struct wire_cst_SdkError_ServiceConnectivity {
15473 err: *mut wire_cst_list_prim_u_8_strict,
15474 }
15475 #[repr(C)]
15476 #[derive(Clone, Copy)]
15477 pub struct wire_cst_sdk_event {
15478 tag: i32,
15479 kind: SdkEventKind,
15480 }
15481 #[repr(C)]
15482 #[derive(Clone, Copy)]
15483 pub union SdkEventKind {
15484 PaymentFailed: wire_cst_SdkEvent_PaymentFailed,
15485 PaymentPending: wire_cst_SdkEvent_PaymentPending,
15486 PaymentRefundable: wire_cst_SdkEvent_PaymentRefundable,
15487 PaymentRefunded: wire_cst_SdkEvent_PaymentRefunded,
15488 PaymentRefundPending: wire_cst_SdkEvent_PaymentRefundPending,
15489 PaymentSucceeded: wire_cst_SdkEvent_PaymentSucceeded,
15490 PaymentWaitingConfirmation: wire_cst_SdkEvent_PaymentWaitingConfirmation,
15491 PaymentWaitingFeeAcceptance: wire_cst_SdkEvent_PaymentWaitingFeeAcceptance,
15492 DataSynced: wire_cst_SdkEvent_DataSynced,
15493 nil__: (),
15494 }
15495 #[repr(C)]
15496 #[derive(Clone, Copy)]
15497 pub struct wire_cst_SdkEvent_PaymentFailed {
15498 details: *mut wire_cst_payment,
15499 }
15500 #[repr(C)]
15501 #[derive(Clone, Copy)]
15502 pub struct wire_cst_SdkEvent_PaymentPending {
15503 details: *mut wire_cst_payment,
15504 }
15505 #[repr(C)]
15506 #[derive(Clone, Copy)]
15507 pub struct wire_cst_SdkEvent_PaymentRefundable {
15508 details: *mut wire_cst_payment,
15509 }
15510 #[repr(C)]
15511 #[derive(Clone, Copy)]
15512 pub struct wire_cst_SdkEvent_PaymentRefunded {
15513 details: *mut wire_cst_payment,
15514 }
15515 #[repr(C)]
15516 #[derive(Clone, Copy)]
15517 pub struct wire_cst_SdkEvent_PaymentRefundPending {
15518 details: *mut wire_cst_payment,
15519 }
15520 #[repr(C)]
15521 #[derive(Clone, Copy)]
15522 pub struct wire_cst_SdkEvent_PaymentSucceeded {
15523 details: *mut wire_cst_payment,
15524 }
15525 #[repr(C)]
15526 #[derive(Clone, Copy)]
15527 pub struct wire_cst_SdkEvent_PaymentWaitingConfirmation {
15528 details: *mut wire_cst_payment,
15529 }
15530 #[repr(C)]
15531 #[derive(Clone, Copy)]
15532 pub struct wire_cst_SdkEvent_PaymentWaitingFeeAcceptance {
15533 details: *mut wire_cst_payment,
15534 }
15535 #[repr(C)]
15536 #[derive(Clone, Copy)]
15537 pub struct wire_cst_SdkEvent_DataSynced {
15538 did_pull_new_records: bool,
15539 }
15540 #[repr(C)]
15541 #[derive(Clone, Copy)]
15542 pub struct wire_cst_send_destination {
15543 tag: i32,
15544 kind: SendDestinationKind,
15545 }
15546 #[repr(C)]
15547 #[derive(Clone, Copy)]
15548 pub union SendDestinationKind {
15549 LiquidAddress: wire_cst_SendDestination_LiquidAddress,
15550 Bolt11: wire_cst_SendDestination_Bolt11,
15551 Bolt12: wire_cst_SendDestination_Bolt12,
15552 nil__: (),
15553 }
15554 #[repr(C)]
15555 #[derive(Clone, Copy)]
15556 pub struct wire_cst_SendDestination_LiquidAddress {
15557 address_data: *mut wire_cst_liquid_address_data,
15558 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15559 }
15560 #[repr(C)]
15561 #[derive(Clone, Copy)]
15562 pub struct wire_cst_SendDestination_Bolt11 {
15563 invoice: *mut wire_cst_ln_invoice,
15564 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15565 }
15566 #[repr(C)]
15567 #[derive(Clone, Copy)]
15568 pub struct wire_cst_SendDestination_Bolt12 {
15569 offer: *mut wire_cst_ln_offer,
15570 receiver_amount_sat: u64,
15571 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15572 }
15573 #[repr(C)]
15574 #[derive(Clone, Copy)]
15575 pub struct wire_cst_send_payment_request {
15576 prepare_response: wire_cst_prepare_send_response,
15577 use_asset_fees: *mut bool,
15578 payer_note: *mut wire_cst_list_prim_u_8_strict,
15579 }
15580 #[repr(C)]
15581 #[derive(Clone, Copy)]
15582 pub struct wire_cst_send_payment_response {
15583 payment: wire_cst_payment,
15584 }
15585 #[repr(C)]
15586 #[derive(Clone, Copy)]
15587 pub struct wire_cst_sign_message_request {
15588 message: *mut wire_cst_list_prim_u_8_strict,
15589 }
15590 #[repr(C)]
15591 #[derive(Clone, Copy)]
15592 pub struct wire_cst_sign_message_response {
15593 signature: *mut wire_cst_list_prim_u_8_strict,
15594 }
15595 #[repr(C)]
15596 #[derive(Clone, Copy)]
15597 pub struct wire_cst_success_action {
15598 tag: i32,
15599 kind: SuccessActionKind,
15600 }
15601 #[repr(C)]
15602 #[derive(Clone, Copy)]
15603 pub union SuccessActionKind {
15604 Aes: wire_cst_SuccessAction_Aes,
15605 Message: wire_cst_SuccessAction_Message,
15606 Url: wire_cst_SuccessAction_Url,
15607 nil__: (),
15608 }
15609 #[repr(C)]
15610 #[derive(Clone, Copy)]
15611 pub struct wire_cst_SuccessAction_Aes {
15612 data: *mut wire_cst_aes_success_action_data,
15613 }
15614 #[repr(C)]
15615 #[derive(Clone, Copy)]
15616 pub struct wire_cst_SuccessAction_Message {
15617 data: *mut wire_cst_message_success_action_data,
15618 }
15619 #[repr(C)]
15620 #[derive(Clone, Copy)]
15621 pub struct wire_cst_SuccessAction_Url {
15622 data: *mut wire_cst_url_success_action_data,
15623 }
15624 #[repr(C)]
15625 #[derive(Clone, Copy)]
15626 pub struct wire_cst_success_action_processed {
15627 tag: i32,
15628 kind: SuccessActionProcessedKind,
15629 }
15630 #[repr(C)]
15631 #[derive(Clone, Copy)]
15632 pub union SuccessActionProcessedKind {
15633 Aes: wire_cst_SuccessActionProcessed_Aes,
15634 Message: wire_cst_SuccessActionProcessed_Message,
15635 Url: wire_cst_SuccessActionProcessed_Url,
15636 nil__: (),
15637 }
15638 #[repr(C)]
15639 #[derive(Clone, Copy)]
15640 pub struct wire_cst_SuccessActionProcessed_Aes {
15641 result: *mut wire_cst_aes_success_action_data_result,
15642 }
15643 #[repr(C)]
15644 #[derive(Clone, Copy)]
15645 pub struct wire_cst_SuccessActionProcessed_Message {
15646 data: *mut wire_cst_message_success_action_data,
15647 }
15648 #[repr(C)]
15649 #[derive(Clone, Copy)]
15650 pub struct wire_cst_SuccessActionProcessed_Url {
15651 data: *mut wire_cst_url_success_action_data,
15652 }
15653 #[repr(C)]
15654 #[derive(Clone, Copy)]
15655 pub struct wire_cst_symbol {
15656 grapheme: *mut wire_cst_list_prim_u_8_strict,
15657 template: *mut wire_cst_list_prim_u_8_strict,
15658 rtl: *mut bool,
15659 position: *mut u32,
15660 }
15661 #[repr(C)]
15662 #[derive(Clone, Copy)]
15663 pub struct wire_cst_url_success_action_data {
15664 description: *mut wire_cst_list_prim_u_8_strict,
15665 url: *mut wire_cst_list_prim_u_8_strict,
15666 matches_callback_domain: bool,
15667 }
15668 #[repr(C)]
15669 #[derive(Clone, Copy)]
15670 pub struct wire_cst_wallet_info {
15671 balance_sat: u64,
15672 pending_send_sat: u64,
15673 pending_receive_sat: u64,
15674 fingerprint: *mut wire_cst_list_prim_u_8_strict,
15675 pubkey: *mut wire_cst_list_prim_u_8_strict,
15676 asset_balances: *mut wire_cst_list_asset_balance,
15677 }
15678}
15679#[cfg(not(target_family = "wasm"))]
15680pub use io::*;