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_onchainFeeRateLeewaySatPerVbyte = <Option<u32>>::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 return crate::model::Config {
2644 liquid_explorer: var_liquidExplorer,
2645 bitcoin_explorer: var_bitcoinExplorer,
2646 working_dir: var_workingDir,
2647 network: var_network,
2648 payment_timeout_sec: var_paymentTimeoutSec,
2649 sync_service_url: var_syncServiceUrl,
2650 zero_conf_max_amount_sat: var_zeroConfMaxAmountSat,
2651 breez_api_key: var_breezApiKey,
2652 external_input_parsers: var_externalInputParsers,
2653 use_default_external_input_parsers: var_useDefaultExternalInputParsers,
2654 onchain_fee_rate_leeway_sat_per_vbyte: var_onchainFeeRateLeewaySatPerVbyte,
2655 asset_metadata: var_assetMetadata,
2656 sideswap_api_key: var_sideswapApiKey,
2657 };
2658 }
2659}
2660
2661impl SseDecode for crate::model::ConnectRequest {
2662 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2664 let mut var_config = <crate::model::Config>::sse_decode(deserializer);
2665 let mut var_mnemonic = <Option<String>>::sse_decode(deserializer);
2666 let mut var_passphrase = <Option<String>>::sse_decode(deserializer);
2667 let mut var_seed = <Option<Vec<u8>>>::sse_decode(deserializer);
2668 return crate::model::ConnectRequest {
2669 config: var_config,
2670 mnemonic: var_mnemonic,
2671 passphrase: var_passphrase,
2672 seed: var_seed,
2673 };
2674 }
2675}
2676
2677impl SseDecode for crate::model::CreateBolt12InvoiceRequest {
2678 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2680 let mut var_offer = <String>::sse_decode(deserializer);
2681 let mut var_invoiceRequest = <String>::sse_decode(deserializer);
2682 return crate::model::CreateBolt12InvoiceRequest {
2683 offer: var_offer,
2684 invoice_request: var_invoiceRequest,
2685 };
2686 }
2687}
2688
2689impl SseDecode for crate::model::CreateBolt12InvoiceResponse {
2690 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2692 let mut var_invoice = <String>::sse_decode(deserializer);
2693 return crate::model::CreateBolt12InvoiceResponse {
2694 invoice: var_invoice,
2695 };
2696 }
2697}
2698
2699impl SseDecode for crate::bindings::CurrencyInfo {
2700 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2702 let mut var_name = <String>::sse_decode(deserializer);
2703 let mut var_fractionSize = <u32>::sse_decode(deserializer);
2704 let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
2705 let mut var_symbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2706 let mut var_uniqSymbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2707 let mut var_localizedName = <Vec<crate::bindings::LocalizedName>>::sse_decode(deserializer);
2708 let mut var_localeOverrides =
2709 <Vec<crate::bindings::LocaleOverrides>>::sse_decode(deserializer);
2710 return crate::bindings::CurrencyInfo {
2711 name: var_name,
2712 fraction_size: var_fractionSize,
2713 spacing: var_spacing,
2714 symbol: var_symbol,
2715 uniq_symbol: var_uniqSymbol,
2716 localized_name: var_localizedName,
2717 locale_overrides: var_localeOverrides,
2718 };
2719 }
2720}
2721
2722impl SseDecode for crate::bindings::ExternalInputParser {
2723 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2725 let mut var_providerId = <String>::sse_decode(deserializer);
2726 let mut var_inputRegex = <String>::sse_decode(deserializer);
2727 let mut var_parserUrl = <String>::sse_decode(deserializer);
2728 return crate::bindings::ExternalInputParser {
2729 provider_id: var_providerId,
2730 input_regex: var_inputRegex,
2731 parser_url: var_parserUrl,
2732 };
2733 }
2734}
2735
2736impl SseDecode for f64 {
2737 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2739 deserializer.cursor.read_f64::<NativeEndian>().unwrap()
2740 }
2741}
2742
2743impl SseDecode for crate::model::FetchPaymentProposedFeesRequest {
2744 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2746 let mut var_swapId = <String>::sse_decode(deserializer);
2747 return crate::model::FetchPaymentProposedFeesRequest {
2748 swap_id: var_swapId,
2749 };
2750 }
2751}
2752
2753impl SseDecode for crate::model::FetchPaymentProposedFeesResponse {
2754 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2756 let mut var_swapId = <String>::sse_decode(deserializer);
2757 let mut var_feesSat = <u64>::sse_decode(deserializer);
2758 let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
2759 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
2760 return crate::model::FetchPaymentProposedFeesResponse {
2761 swap_id: var_swapId,
2762 fees_sat: var_feesSat,
2763 payer_amount_sat: var_payerAmountSat,
2764 receiver_amount_sat: var_receiverAmountSat,
2765 };
2766 }
2767}
2768
2769impl SseDecode for crate::bindings::FiatCurrency {
2770 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2772 let mut var_id = <String>::sse_decode(deserializer);
2773 let mut var_info = <crate::bindings::CurrencyInfo>::sse_decode(deserializer);
2774 return crate::bindings::FiatCurrency {
2775 id: var_id,
2776 info: var_info,
2777 };
2778 }
2779}
2780
2781impl SseDecode for crate::model::GetInfoResponse {
2782 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2784 let mut var_walletInfo = <crate::model::WalletInfo>::sse_decode(deserializer);
2785 let mut var_blockchainInfo = <crate::model::BlockchainInfo>::sse_decode(deserializer);
2786 return crate::model::GetInfoResponse {
2787 wallet_info: var_walletInfo,
2788 blockchain_info: var_blockchainInfo,
2789 };
2790 }
2791}
2792
2793impl SseDecode for crate::model::GetPaymentRequest {
2794 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2796 let mut tag_ = <i32>::sse_decode(deserializer);
2797 match tag_ {
2798 0 => {
2799 let mut var_paymentHash = <String>::sse_decode(deserializer);
2800 return crate::model::GetPaymentRequest::PaymentHash {
2801 payment_hash: var_paymentHash,
2802 };
2803 }
2804 1 => {
2805 let mut var_swapId = <String>::sse_decode(deserializer);
2806 return crate::model::GetPaymentRequest::SwapId {
2807 swap_id: var_swapId,
2808 };
2809 }
2810 _ => {
2811 unimplemented!("");
2812 }
2813 }
2814 }
2815}
2816
2817impl SseDecode for i32 {
2818 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2820 deserializer.cursor.read_i32::<NativeEndian>().unwrap()
2821 }
2822}
2823
2824impl SseDecode for i64 {
2825 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2827 deserializer.cursor.read_i64::<NativeEndian>().unwrap()
2828 }
2829}
2830
2831impl SseDecode for crate::bindings::InputType {
2832 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2834 let mut tag_ = <i32>::sse_decode(deserializer);
2835 match tag_ {
2836 0 => {
2837 let mut var_address =
2838 <crate::bindings::BitcoinAddressData>::sse_decode(deserializer);
2839 return crate::bindings::InputType::BitcoinAddress {
2840 address: var_address,
2841 };
2842 }
2843 1 => {
2844 let mut var_address =
2845 <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
2846 return crate::bindings::InputType::LiquidAddress {
2847 address: var_address,
2848 };
2849 }
2850 2 => {
2851 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
2852 return crate::bindings::InputType::Bolt11 {
2853 invoice: var_invoice,
2854 };
2855 }
2856 3 => {
2857 let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
2858 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2859 return crate::bindings::InputType::Bolt12Offer {
2860 offer: var_offer,
2861 bip353_address: var_bip353Address,
2862 };
2863 }
2864 4 => {
2865 let mut var_nodeId = <String>::sse_decode(deserializer);
2866 return crate::bindings::InputType::NodeId {
2867 node_id: var_nodeId,
2868 };
2869 }
2870 5 => {
2871 let mut var_url = <String>::sse_decode(deserializer);
2872 return crate::bindings::InputType::Url { url: var_url };
2873 }
2874 6 => {
2875 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
2876 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2877 return crate::bindings::InputType::LnUrlPay {
2878 data: var_data,
2879 bip353_address: var_bip353Address,
2880 };
2881 }
2882 7 => {
2883 let mut var_data =
2884 <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
2885 return crate::bindings::InputType::LnUrlWithdraw { data: var_data };
2886 }
2887 8 => {
2888 let mut var_data =
2889 <crate::bindings::LnUrlAuthRequestData>::sse_decode(deserializer);
2890 return crate::bindings::InputType::LnUrlAuth { data: var_data };
2891 }
2892 9 => {
2893 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
2894 return crate::bindings::InputType::LnUrlError { data: var_data };
2895 }
2896 _ => {
2897 unimplemented!("");
2898 }
2899 }
2900 }
2901}
2902
2903impl SseDecode for crate::model::LightningPaymentLimitsResponse {
2904 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2906 let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
2907 let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
2908 return crate::model::LightningPaymentLimitsResponse {
2909 send: var_send,
2910 receive: var_receive,
2911 };
2912 }
2913}
2914
2915impl SseDecode for crate::model::Limits {
2916 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2918 let mut var_minSat = <u64>::sse_decode(deserializer);
2919 let mut var_maxSat = <u64>::sse_decode(deserializer);
2920 let mut var_maxZeroConfSat = <u64>::sse_decode(deserializer);
2921 return crate::model::Limits {
2922 min_sat: var_minSat,
2923 max_sat: var_maxSat,
2924 max_zero_conf_sat: var_maxZeroConfSat,
2925 };
2926 }
2927}
2928
2929impl SseDecode for crate::bindings::LiquidAddressData {
2930 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2932 let mut var_address = <String>::sse_decode(deserializer);
2933 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2934 let mut var_assetId = <Option<String>>::sse_decode(deserializer);
2935 let mut var_amount = <Option<f64>>::sse_decode(deserializer);
2936 let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2937 let mut var_label = <Option<String>>::sse_decode(deserializer);
2938 let mut var_message = <Option<String>>::sse_decode(deserializer);
2939 return crate::bindings::LiquidAddressData {
2940 address: var_address,
2941 network: var_network,
2942 asset_id: var_assetId,
2943 amount: var_amount,
2944 amount_sat: var_amountSat,
2945 label: var_label,
2946 message: var_message,
2947 };
2948 }
2949}
2950
2951impl SseDecode for crate::model::LiquidNetwork {
2952 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2954 let mut inner = <i32>::sse_decode(deserializer);
2955 return match inner {
2956 0 => crate::model::LiquidNetwork::Mainnet,
2957 1 => crate::model::LiquidNetwork::Testnet,
2958 2 => crate::model::LiquidNetwork::Regtest,
2959 _ => unreachable!("Invalid variant for LiquidNetwork: {}", inner),
2960 };
2961 }
2962}
2963
2964impl SseDecode for Vec<String> {
2965 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2967 let mut len_ = <i32>::sse_decode(deserializer);
2968 let mut ans_ = vec![];
2969 for idx_ in 0..len_ {
2970 ans_.push(<String>::sse_decode(deserializer));
2971 }
2972 return ans_;
2973 }
2974}
2975
2976impl SseDecode for Vec<crate::model::AssetBalance> {
2977 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2979 let mut len_ = <i32>::sse_decode(deserializer);
2980 let mut ans_ = vec![];
2981 for idx_ in 0..len_ {
2982 ans_.push(<crate::model::AssetBalance>::sse_decode(deserializer));
2983 }
2984 return ans_;
2985 }
2986}
2987
2988impl SseDecode for Vec<crate::model::AssetMetadata> {
2989 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2991 let mut len_ = <i32>::sse_decode(deserializer);
2992 let mut ans_ = vec![];
2993 for idx_ in 0..len_ {
2994 ans_.push(<crate::model::AssetMetadata>::sse_decode(deserializer));
2995 }
2996 return ans_;
2997 }
2998}
2999
3000impl SseDecode for Vec<crate::bindings::ExternalInputParser> {
3001 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3003 let mut len_ = <i32>::sse_decode(deserializer);
3004 let mut ans_ = vec![];
3005 for idx_ in 0..len_ {
3006 ans_.push(<crate::bindings::ExternalInputParser>::sse_decode(
3007 deserializer,
3008 ));
3009 }
3010 return ans_;
3011 }
3012}
3013
3014impl SseDecode for Vec<crate::bindings::FiatCurrency> {
3015 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3017 let mut len_ = <i32>::sse_decode(deserializer);
3018 let mut ans_ = vec![];
3019 for idx_ in 0..len_ {
3020 ans_.push(<crate::bindings::FiatCurrency>::sse_decode(deserializer));
3021 }
3022 return ans_;
3023 }
3024}
3025
3026impl SseDecode for Vec<crate::bindings::LnOfferBlindedPath> {
3027 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3029 let mut len_ = <i32>::sse_decode(deserializer);
3030 let mut ans_ = vec![];
3031 for idx_ in 0..len_ {
3032 ans_.push(<crate::bindings::LnOfferBlindedPath>::sse_decode(
3033 deserializer,
3034 ));
3035 }
3036 return ans_;
3037 }
3038}
3039
3040impl SseDecode for Vec<crate::bindings::LocaleOverrides> {
3041 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3043 let mut len_ = <i32>::sse_decode(deserializer);
3044 let mut ans_ = vec![];
3045 for idx_ in 0..len_ {
3046 ans_.push(<crate::bindings::LocaleOverrides>::sse_decode(deserializer));
3047 }
3048 return ans_;
3049 }
3050}
3051
3052impl SseDecode for Vec<crate::bindings::LocalizedName> {
3053 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3055 let mut len_ = <i32>::sse_decode(deserializer);
3056 let mut ans_ = vec![];
3057 for idx_ in 0..len_ {
3058 ans_.push(<crate::bindings::LocalizedName>::sse_decode(deserializer));
3059 }
3060 return ans_;
3061 }
3062}
3063
3064impl SseDecode for Vec<crate::model::Payment> {
3065 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3067 let mut len_ = <i32>::sse_decode(deserializer);
3068 let mut ans_ = vec![];
3069 for idx_ in 0..len_ {
3070 ans_.push(<crate::model::Payment>::sse_decode(deserializer));
3071 }
3072 return ans_;
3073 }
3074}
3075
3076impl SseDecode for crate::model::ListPaymentDetails {
3077 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3079 let mut tag_ = <i32>::sse_decode(deserializer);
3080 match tag_ {
3081 0 => {
3082 let mut var_assetId = <Option<String>>::sse_decode(deserializer);
3083 let mut var_destination = <Option<String>>::sse_decode(deserializer);
3084 return crate::model::ListPaymentDetails::Liquid {
3085 asset_id: var_assetId,
3086 destination: var_destination,
3087 };
3088 }
3089 1 => {
3090 let mut var_address = <Option<String>>::sse_decode(deserializer);
3091 return crate::model::ListPaymentDetails::Bitcoin {
3092 address: var_address,
3093 };
3094 }
3095 _ => {
3096 unimplemented!("");
3097 }
3098 }
3099 }
3100}
3101
3102impl SseDecode for Vec<crate::model::PaymentState> {
3103 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3105 let mut len_ = <i32>::sse_decode(deserializer);
3106 let mut ans_ = vec![];
3107 for idx_ in 0..len_ {
3108 ans_.push(<crate::model::PaymentState>::sse_decode(deserializer));
3109 }
3110 return ans_;
3111 }
3112}
3113
3114impl SseDecode for Vec<crate::model::PaymentType> {
3115 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3117 let mut len_ = <i32>::sse_decode(deserializer);
3118 let mut ans_ = vec![];
3119 for idx_ in 0..len_ {
3120 ans_.push(<crate::model::PaymentType>::sse_decode(deserializer));
3121 }
3122 return ans_;
3123 }
3124}
3125
3126impl SseDecode for crate::model::ListPaymentsRequest {
3127 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3129 let mut var_filters = <Option<Vec<crate::model::PaymentType>>>::sse_decode(deserializer);
3130 let mut var_states = <Option<Vec<crate::model::PaymentState>>>::sse_decode(deserializer);
3131 let mut var_fromTimestamp = <Option<i64>>::sse_decode(deserializer);
3132 let mut var_toTimestamp = <Option<i64>>::sse_decode(deserializer);
3133 let mut var_offset = <Option<u32>>::sse_decode(deserializer);
3134 let mut var_limit = <Option<u32>>::sse_decode(deserializer);
3135 let mut var_details = <Option<crate::model::ListPaymentDetails>>::sse_decode(deserializer);
3136 let mut var_sortAscending = <Option<bool>>::sse_decode(deserializer);
3137 return crate::model::ListPaymentsRequest {
3138 filters: var_filters,
3139 states: var_states,
3140 from_timestamp: var_fromTimestamp,
3141 to_timestamp: var_toTimestamp,
3142 offset: var_offset,
3143 limit: var_limit,
3144 details: var_details,
3145 sort_ascending: var_sortAscending,
3146 };
3147 }
3148}
3149
3150impl SseDecode for Vec<u8> {
3151 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3153 let mut len_ = <i32>::sse_decode(deserializer);
3154 let mut ans_ = vec![];
3155 for idx_ in 0..len_ {
3156 ans_.push(<u8>::sse_decode(deserializer));
3157 }
3158 return ans_;
3159 }
3160}
3161
3162impl SseDecode for Vec<crate::bindings::Rate> {
3163 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3165 let mut len_ = <i32>::sse_decode(deserializer);
3166 let mut ans_ = vec![];
3167 for idx_ in 0..len_ {
3168 ans_.push(<crate::bindings::Rate>::sse_decode(deserializer));
3169 }
3170 return ans_;
3171 }
3172}
3173
3174impl SseDecode for Vec<crate::model::RefundableSwap> {
3175 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3177 let mut len_ = <i32>::sse_decode(deserializer);
3178 let mut ans_ = vec![];
3179 for idx_ in 0..len_ {
3180 ans_.push(<crate::model::RefundableSwap>::sse_decode(deserializer));
3181 }
3182 return ans_;
3183 }
3184}
3185
3186impl SseDecode for Vec<crate::bindings::RouteHint> {
3187 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3189 let mut len_ = <i32>::sse_decode(deserializer);
3190 let mut ans_ = vec![];
3191 for idx_ in 0..len_ {
3192 ans_.push(<crate::bindings::RouteHint>::sse_decode(deserializer));
3193 }
3194 return ans_;
3195 }
3196}
3197
3198impl SseDecode for Vec<crate::bindings::RouteHintHop> {
3199 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3201 let mut len_ = <i32>::sse_decode(deserializer);
3202 let mut ans_ = vec![];
3203 for idx_ in 0..len_ {
3204 ans_.push(<crate::bindings::RouteHintHop>::sse_decode(deserializer));
3205 }
3206 return ans_;
3207 }
3208}
3209
3210impl SseDecode for crate::bindings::LNInvoice {
3211 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3213 let mut var_bolt11 = <String>::sse_decode(deserializer);
3214 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
3215 let mut var_payeePubkey = <String>::sse_decode(deserializer);
3216 let mut var_paymentHash = <String>::sse_decode(deserializer);
3217 let mut var_description = <Option<String>>::sse_decode(deserializer);
3218 let mut var_descriptionHash = <Option<String>>::sse_decode(deserializer);
3219 let mut var_amountMsat = <Option<u64>>::sse_decode(deserializer);
3220 let mut var_timestamp = <u64>::sse_decode(deserializer);
3221 let mut var_expiry = <u64>::sse_decode(deserializer);
3222 let mut var_routingHints = <Vec<crate::bindings::RouteHint>>::sse_decode(deserializer);
3223 let mut var_paymentSecret = <Vec<u8>>::sse_decode(deserializer);
3224 let mut var_minFinalCltvExpiryDelta = <u64>::sse_decode(deserializer);
3225 return crate::bindings::LNInvoice {
3226 bolt11: var_bolt11,
3227 network: var_network,
3228 payee_pubkey: var_payeePubkey,
3229 payment_hash: var_paymentHash,
3230 description: var_description,
3231 description_hash: var_descriptionHash,
3232 amount_msat: var_amountMsat,
3233 timestamp: var_timestamp,
3234 expiry: var_expiry,
3235 routing_hints: var_routingHints,
3236 payment_secret: var_paymentSecret,
3237 min_final_cltv_expiry_delta: var_minFinalCltvExpiryDelta,
3238 };
3239 }
3240}
3241
3242impl SseDecode for crate::bindings::LNOffer {
3243 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3245 let mut var_offer = <String>::sse_decode(deserializer);
3246 let mut var_chains = <Vec<String>>::sse_decode(deserializer);
3247 let mut var_minAmount = <Option<crate::bindings::Amount>>::sse_decode(deserializer);
3248 let mut var_description = <Option<String>>::sse_decode(deserializer);
3249 let mut var_absoluteExpiry = <Option<u64>>::sse_decode(deserializer);
3250 let mut var_issuer = <Option<String>>::sse_decode(deserializer);
3251 let mut var_signingPubkey = <Option<String>>::sse_decode(deserializer);
3252 let mut var_paths = <Vec<crate::bindings::LnOfferBlindedPath>>::sse_decode(deserializer);
3253 return crate::bindings::LNOffer {
3254 offer: var_offer,
3255 chains: var_chains,
3256 min_amount: var_minAmount,
3257 description: var_description,
3258 absolute_expiry: var_absoluteExpiry,
3259 issuer: var_issuer,
3260 signing_pubkey: var_signingPubkey,
3261 paths: var_paths,
3262 };
3263 }
3264}
3265
3266impl SseDecode for crate::bindings::LnOfferBlindedPath {
3267 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3269 let mut var_blindedHops = <Vec<String>>::sse_decode(deserializer);
3270 return crate::bindings::LnOfferBlindedPath {
3271 blinded_hops: var_blindedHops,
3272 };
3273 }
3274}
3275
3276impl SseDecode for crate::bindings::duplicates::LnUrlAuthError {
3277 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3279 let mut tag_ = <i32>::sse_decode(deserializer);
3280 match tag_ {
3281 0 => {
3282 let mut var_err = <String>::sse_decode(deserializer);
3283 return crate::bindings::duplicates::LnUrlAuthError::Generic { err: var_err };
3284 }
3285 1 => {
3286 let mut var_err = <String>::sse_decode(deserializer);
3287 return crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err: var_err };
3288 }
3289 2 => {
3290 let mut var_err = <String>::sse_decode(deserializer);
3291 return crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
3292 err: var_err,
3293 };
3294 }
3295 _ => {
3296 unimplemented!("");
3297 }
3298 }
3299 }
3300}
3301
3302impl SseDecode for crate::bindings::LnUrlAuthRequestData {
3303 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3305 let mut var_k1 = <String>::sse_decode(deserializer);
3306 let mut var_action = <Option<String>>::sse_decode(deserializer);
3307 let mut var_domain = <String>::sse_decode(deserializer);
3308 let mut var_url = <String>::sse_decode(deserializer);
3309 return crate::bindings::LnUrlAuthRequestData {
3310 k1: var_k1,
3311 action: var_action,
3312 domain: var_domain,
3313 url: var_url,
3314 };
3315 }
3316}
3317
3318impl SseDecode for crate::bindings::duplicates::LnUrlCallbackStatus {
3319 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3321 let mut tag_ = <i32>::sse_decode(deserializer);
3322 match tag_ {
3323 0 => {
3324 return crate::bindings::duplicates::LnUrlCallbackStatus::Ok;
3325 }
3326 1 => {
3327 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3328 return crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
3329 data: var_data,
3330 };
3331 }
3332 _ => {
3333 unimplemented!("");
3334 }
3335 }
3336 }
3337}
3338
3339impl SseDecode for crate::bindings::LnUrlErrorData {
3340 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3342 let mut var_reason = <String>::sse_decode(deserializer);
3343 return crate::bindings::LnUrlErrorData { reason: var_reason };
3344 }
3345}
3346
3347impl SseDecode for crate::model::LnUrlInfo {
3348 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3350 let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3351 let mut var_lnurlPayComment = <Option<String>>::sse_decode(deserializer);
3352 let mut var_lnurlPayDomain = <Option<String>>::sse_decode(deserializer);
3353 let mut var_lnurlPayMetadata = <Option<String>>::sse_decode(deserializer);
3354 let mut var_lnurlPaySuccessAction =
3355 <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3356 let mut var_lnurlPayUnprocessedSuccessAction =
3357 <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
3358 let mut var_lnurlWithdrawEndpoint = <Option<String>>::sse_decode(deserializer);
3359 return crate::model::LnUrlInfo {
3360 ln_address: var_lnAddress,
3361 lnurl_pay_comment: var_lnurlPayComment,
3362 lnurl_pay_domain: var_lnurlPayDomain,
3363 lnurl_pay_metadata: var_lnurlPayMetadata,
3364 lnurl_pay_success_action: var_lnurlPaySuccessAction,
3365 lnurl_pay_unprocessed_success_action: var_lnurlPayUnprocessedSuccessAction,
3366 lnurl_withdraw_endpoint: var_lnurlWithdrawEndpoint,
3367 };
3368 }
3369}
3370
3371impl SseDecode for crate::bindings::duplicates::LnUrlPayError {
3372 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3374 let mut tag_ = <i32>::sse_decode(deserializer);
3375 match tag_ {
3376 0 => {
3377 return crate::bindings::duplicates::LnUrlPayError::AlreadyPaid;
3378 }
3379 1 => {
3380 let mut var_err = <String>::sse_decode(deserializer);
3381 return crate::bindings::duplicates::LnUrlPayError::Generic { err: var_err };
3382 }
3383 2 => {
3384 let mut var_err = <String>::sse_decode(deserializer);
3385 return crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
3386 err: var_err,
3387 };
3388 }
3389 3 => {
3390 let mut var_err = <String>::sse_decode(deserializer);
3391 return crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err: var_err };
3392 }
3393 4 => {
3394 let mut var_err = <String>::sse_decode(deserializer);
3395 return crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err: var_err };
3396 }
3397 5 => {
3398 let mut var_err = <String>::sse_decode(deserializer);
3399 return crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err: var_err };
3400 }
3401 6 => {
3402 let mut var_err = <String>::sse_decode(deserializer);
3403 return crate::bindings::duplicates::LnUrlPayError::InvalidUri { err: var_err };
3404 }
3405 7 => {
3406 let mut var_err = <String>::sse_decode(deserializer);
3407 return crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err: var_err };
3408 }
3409 8 => {
3410 let mut var_err = <String>::sse_decode(deserializer);
3411 return crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err: var_err };
3412 }
3413 9 => {
3414 let mut var_err = <String>::sse_decode(deserializer);
3415 return crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err: var_err };
3416 }
3417 10 => {
3418 let mut var_err = <String>::sse_decode(deserializer);
3419 return crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err: var_err };
3420 }
3421 11 => {
3422 let mut var_err = <String>::sse_decode(deserializer);
3423 return crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
3424 err: var_err,
3425 };
3426 }
3427 12 => {
3428 let mut var_err = <String>::sse_decode(deserializer);
3429 return crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
3430 err: var_err,
3431 };
3432 }
3433 _ => {
3434 unimplemented!("");
3435 }
3436 }
3437 }
3438}
3439
3440impl SseDecode for crate::bindings::LnUrlPayErrorData {
3441 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3443 let mut var_paymentHash = <String>::sse_decode(deserializer);
3444 let mut var_reason = <String>::sse_decode(deserializer);
3445 return crate::bindings::LnUrlPayErrorData {
3446 payment_hash: var_paymentHash,
3447 reason: var_reason,
3448 };
3449 }
3450}
3451
3452impl SseDecode for crate::model::LnUrlPayRequest {
3453 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3455 let mut var_prepareResponse =
3456 <crate::model::PrepareLnUrlPayResponse>::sse_decode(deserializer);
3457 return crate::model::LnUrlPayRequest {
3458 prepare_response: var_prepareResponse,
3459 };
3460 }
3461}
3462
3463impl SseDecode for crate::bindings::LnUrlPayRequestData {
3464 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3466 let mut var_callback = <String>::sse_decode(deserializer);
3467 let mut var_minSendable = <u64>::sse_decode(deserializer);
3468 let mut var_maxSendable = <u64>::sse_decode(deserializer);
3469 let mut var_metadataStr = <String>::sse_decode(deserializer);
3470 let mut var_commentAllowed = <u16>::sse_decode(deserializer);
3471 let mut var_domain = <String>::sse_decode(deserializer);
3472 let mut var_allowsNostr = <bool>::sse_decode(deserializer);
3473 let mut var_nostrPubkey = <Option<String>>::sse_decode(deserializer);
3474 let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3475 return crate::bindings::LnUrlPayRequestData {
3476 callback: var_callback,
3477 min_sendable: var_minSendable,
3478 max_sendable: var_maxSendable,
3479 metadata_str: var_metadataStr,
3480 comment_allowed: var_commentAllowed,
3481 domain: var_domain,
3482 allows_nostr: var_allowsNostr,
3483 nostr_pubkey: var_nostrPubkey,
3484 ln_address: var_lnAddress,
3485 };
3486 }
3487}
3488
3489impl SseDecode for crate::model::LnUrlPayResult {
3490 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3492 let mut tag_ = <i32>::sse_decode(deserializer);
3493 match tag_ {
3494 0 => {
3495 let mut var_data = <crate::model::LnUrlPaySuccessData>::sse_decode(deserializer);
3496 return crate::model::LnUrlPayResult::EndpointSuccess { data: var_data };
3497 }
3498 1 => {
3499 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3500 return crate::model::LnUrlPayResult::EndpointError { data: var_data };
3501 }
3502 2 => {
3503 let mut var_data = <crate::bindings::LnUrlPayErrorData>::sse_decode(deserializer);
3504 return crate::model::LnUrlPayResult::PayError { data: var_data };
3505 }
3506 _ => {
3507 unimplemented!("");
3508 }
3509 }
3510 }
3511}
3512
3513impl SseDecode for crate::model::LnUrlPaySuccessData {
3514 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3516 let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
3517 let mut var_successAction =
3518 <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3519 return crate::model::LnUrlPaySuccessData {
3520 payment: var_payment,
3521 success_action: var_successAction,
3522 };
3523 }
3524}
3525
3526impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawError {
3527 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3529 let mut tag_ = <i32>::sse_decode(deserializer);
3530 match tag_ {
3531 0 => {
3532 let mut var_err = <String>::sse_decode(deserializer);
3533 return crate::bindings::duplicates::LnUrlWithdrawError::Generic { err: var_err };
3534 }
3535 1 => {
3536 let mut var_err = <String>::sse_decode(deserializer);
3537 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
3538 err: var_err,
3539 };
3540 }
3541 2 => {
3542 let mut var_err = <String>::sse_decode(deserializer);
3543 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
3544 err: var_err,
3545 };
3546 }
3547 3 => {
3548 let mut var_err = <String>::sse_decode(deserializer);
3549 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
3550 err: var_err,
3551 };
3552 }
3553 4 => {
3554 let mut var_err = <String>::sse_decode(deserializer);
3555 return crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
3556 err: var_err,
3557 };
3558 }
3559 5 => {
3560 let mut var_err = <String>::sse_decode(deserializer);
3561 return crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
3562 err: var_err,
3563 };
3564 }
3565 _ => {
3566 unimplemented!("");
3567 }
3568 }
3569 }
3570}
3571
3572impl SseDecode for crate::bindings::LnUrlWithdrawRequest {
3573 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3575 let mut var_data = <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
3576 let mut var_amountMsat = <u64>::sse_decode(deserializer);
3577 let mut var_description = <Option<String>>::sse_decode(deserializer);
3578 return crate::bindings::LnUrlWithdrawRequest {
3579 data: var_data,
3580 amount_msat: var_amountMsat,
3581 description: var_description,
3582 };
3583 }
3584}
3585
3586impl SseDecode for crate::bindings::LnUrlWithdrawRequestData {
3587 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3589 let mut var_callback = <String>::sse_decode(deserializer);
3590 let mut var_k1 = <String>::sse_decode(deserializer);
3591 let mut var_defaultDescription = <String>::sse_decode(deserializer);
3592 let mut var_minWithdrawable = <u64>::sse_decode(deserializer);
3593 let mut var_maxWithdrawable = <u64>::sse_decode(deserializer);
3594 return crate::bindings::LnUrlWithdrawRequestData {
3595 callback: var_callback,
3596 k1: var_k1,
3597 default_description: var_defaultDescription,
3598 min_withdrawable: var_minWithdrawable,
3599 max_withdrawable: var_maxWithdrawable,
3600 };
3601 }
3602}
3603
3604impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawResult {
3605 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3607 let mut tag_ = <i32>::sse_decode(deserializer);
3608 match tag_ {
3609 0 => {
3610 let mut var_data =
3611 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3612 deserializer,
3613 );
3614 return crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data: var_data };
3615 }
3616 1 => {
3617 let mut var_data =
3618 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3619 deserializer,
3620 );
3621 return crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
3622 data: var_data,
3623 };
3624 }
3625 2 => {
3626 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3627 return crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
3628 data: var_data,
3629 };
3630 }
3631 _ => {
3632 unimplemented!("");
3633 }
3634 }
3635 }
3636}
3637
3638impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3639 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3641 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
3642 return crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3643 invoice: var_invoice,
3644 };
3645 }
3646}
3647
3648impl SseDecode for crate::bindings::LocaleOverrides {
3649 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3651 let mut var_locale = <String>::sse_decode(deserializer);
3652 let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
3653 let mut var_symbol = <crate::bindings::Symbol>::sse_decode(deserializer);
3654 return crate::bindings::LocaleOverrides {
3655 locale: var_locale,
3656 spacing: var_spacing,
3657 symbol: var_symbol,
3658 };
3659 }
3660}
3661
3662impl SseDecode for crate::bindings::LocalizedName {
3663 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3665 let mut var_locale = <String>::sse_decode(deserializer);
3666 let mut var_name = <String>::sse_decode(deserializer);
3667 return crate::bindings::LocalizedName {
3668 locale: var_locale,
3669 name: var_name,
3670 };
3671 }
3672}
3673
3674impl SseDecode for crate::model::LogEntry {
3675 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3677 let mut var_line = <String>::sse_decode(deserializer);
3678 let mut var_level = <String>::sse_decode(deserializer);
3679 return crate::model::LogEntry {
3680 line: var_line,
3681 level: var_level,
3682 };
3683 }
3684}
3685
3686impl SseDecode for crate::bindings::MessageSuccessActionData {
3687 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3689 let mut var_message = <String>::sse_decode(deserializer);
3690 return crate::bindings::MessageSuccessActionData {
3691 message: var_message,
3692 };
3693 }
3694}
3695
3696impl SseDecode for crate::bindings::Network {
3697 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3699 let mut inner = <i32>::sse_decode(deserializer);
3700 return match inner {
3701 0 => crate::bindings::Network::Bitcoin,
3702 1 => crate::bindings::Network::Testnet,
3703 2 => crate::bindings::Network::Signet,
3704 3 => crate::bindings::Network::Regtest,
3705 _ => unreachable!("Invalid variant for Network: {}", inner),
3706 };
3707 }
3708}
3709
3710impl SseDecode for crate::model::OnchainPaymentLimitsResponse {
3711 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3713 let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
3714 let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
3715 return crate::model::OnchainPaymentLimitsResponse {
3716 send: var_send,
3717 receive: var_receive,
3718 };
3719 }
3720}
3721
3722impl SseDecode for Option<String> {
3723 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3725 if (<bool>::sse_decode(deserializer)) {
3726 return Some(<String>::sse_decode(deserializer));
3727 } else {
3728 return None;
3729 }
3730 }
3731}
3732
3733impl SseDecode for Option<crate::bindings::Amount> {
3734 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3736 if (<bool>::sse_decode(deserializer)) {
3737 return Some(<crate::bindings::Amount>::sse_decode(deserializer));
3738 } else {
3739 return None;
3740 }
3741 }
3742}
3743
3744impl SseDecode for Option<crate::model::AssetInfo> {
3745 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3747 if (<bool>::sse_decode(deserializer)) {
3748 return Some(<crate::model::AssetInfo>::sse_decode(deserializer));
3749 } else {
3750 return None;
3751 }
3752 }
3753}
3754
3755impl SseDecode for Option<bool> {
3756 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3758 if (<bool>::sse_decode(deserializer)) {
3759 return Some(<bool>::sse_decode(deserializer));
3760 } else {
3761 return None;
3762 }
3763 }
3764}
3765
3766impl SseDecode for Option<f64> {
3767 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3769 if (<bool>::sse_decode(deserializer)) {
3770 return Some(<f64>::sse_decode(deserializer));
3771 } else {
3772 return None;
3773 }
3774 }
3775}
3776
3777impl SseDecode for Option<i64> {
3778 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3780 if (<bool>::sse_decode(deserializer)) {
3781 return Some(<i64>::sse_decode(deserializer));
3782 } else {
3783 return None;
3784 }
3785 }
3786}
3787
3788impl SseDecode for Option<crate::model::ListPaymentDetails> {
3789 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3791 if (<bool>::sse_decode(deserializer)) {
3792 return Some(<crate::model::ListPaymentDetails>::sse_decode(deserializer));
3793 } else {
3794 return None;
3795 }
3796 }
3797}
3798
3799impl SseDecode for Option<crate::model::LnUrlInfo> {
3800 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3802 if (<bool>::sse_decode(deserializer)) {
3803 return Some(<crate::model::LnUrlInfo>::sse_decode(deserializer));
3804 } else {
3805 return None;
3806 }
3807 }
3808}
3809
3810impl SseDecode for Option<crate::model::PayAmount> {
3811 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3813 if (<bool>::sse_decode(deserializer)) {
3814 return Some(<crate::model::PayAmount>::sse_decode(deserializer));
3815 } else {
3816 return None;
3817 }
3818 }
3819}
3820
3821impl SseDecode for Option<crate::model::Payment> {
3822 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3824 if (<bool>::sse_decode(deserializer)) {
3825 return Some(<crate::model::Payment>::sse_decode(deserializer));
3826 } else {
3827 return None;
3828 }
3829 }
3830}
3831
3832impl SseDecode for Option<crate::model::ReceiveAmount> {
3833 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3835 if (<bool>::sse_decode(deserializer)) {
3836 return Some(<crate::model::ReceiveAmount>::sse_decode(deserializer));
3837 } else {
3838 return None;
3839 }
3840 }
3841}
3842
3843impl SseDecode for Option<crate::bindings::SuccessAction> {
3844 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3846 if (<bool>::sse_decode(deserializer)) {
3847 return Some(<crate::bindings::SuccessAction>::sse_decode(deserializer));
3848 } else {
3849 return None;
3850 }
3851 }
3852}
3853
3854impl SseDecode for Option<crate::bindings::SuccessActionProcessed> {
3855 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3857 if (<bool>::sse_decode(deserializer)) {
3858 return Some(<crate::bindings::SuccessActionProcessed>::sse_decode(
3859 deserializer,
3860 ));
3861 } else {
3862 return None;
3863 }
3864 }
3865}
3866
3867impl SseDecode for Option<crate::bindings::Symbol> {
3868 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3870 if (<bool>::sse_decode(deserializer)) {
3871 return Some(<crate::bindings::Symbol>::sse_decode(deserializer));
3872 } else {
3873 return None;
3874 }
3875 }
3876}
3877
3878impl SseDecode for Option<u32> {
3879 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3881 if (<bool>::sse_decode(deserializer)) {
3882 return Some(<u32>::sse_decode(deserializer));
3883 } else {
3884 return None;
3885 }
3886 }
3887}
3888
3889impl SseDecode for Option<u64> {
3890 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3892 if (<bool>::sse_decode(deserializer)) {
3893 return Some(<u64>::sse_decode(deserializer));
3894 } else {
3895 return None;
3896 }
3897 }
3898}
3899
3900impl SseDecode for Option<Vec<crate::model::AssetMetadata>> {
3901 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3903 if (<bool>::sse_decode(deserializer)) {
3904 return Some(<Vec<crate::model::AssetMetadata>>::sse_decode(deserializer));
3905 } else {
3906 return None;
3907 }
3908 }
3909}
3910
3911impl SseDecode for Option<Vec<crate::bindings::ExternalInputParser>> {
3912 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3914 if (<bool>::sse_decode(deserializer)) {
3915 return Some(<Vec<crate::bindings::ExternalInputParser>>::sse_decode(
3916 deserializer,
3917 ));
3918 } else {
3919 return None;
3920 }
3921 }
3922}
3923
3924impl SseDecode for Option<Vec<crate::model::PaymentState>> {
3925 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3927 if (<bool>::sse_decode(deserializer)) {
3928 return Some(<Vec<crate::model::PaymentState>>::sse_decode(deserializer));
3929 } else {
3930 return None;
3931 }
3932 }
3933}
3934
3935impl SseDecode for Option<Vec<crate::model::PaymentType>> {
3936 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3938 if (<bool>::sse_decode(deserializer)) {
3939 return Some(<Vec<crate::model::PaymentType>>::sse_decode(deserializer));
3940 } else {
3941 return None;
3942 }
3943 }
3944}
3945
3946impl SseDecode for Option<Vec<u8>> {
3947 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3949 if (<bool>::sse_decode(deserializer)) {
3950 return Some(<Vec<u8>>::sse_decode(deserializer));
3951 } else {
3952 return None;
3953 }
3954 }
3955}
3956
3957impl SseDecode for crate::model::PayAmount {
3958 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3960 let mut tag_ = <i32>::sse_decode(deserializer);
3961 match tag_ {
3962 0 => {
3963 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
3964 return crate::model::PayAmount::Bitcoin {
3965 receiver_amount_sat: var_receiverAmountSat,
3966 };
3967 }
3968 1 => {
3969 let mut var_assetId = <String>::sse_decode(deserializer);
3970 let mut var_receiverAmount = <f64>::sse_decode(deserializer);
3971 let mut var_estimateAssetFees = <Option<bool>>::sse_decode(deserializer);
3972 return crate::model::PayAmount::Asset {
3973 asset_id: var_assetId,
3974 receiver_amount: var_receiverAmount,
3975 estimate_asset_fees: var_estimateAssetFees,
3976 };
3977 }
3978 2 => {
3979 return crate::model::PayAmount::Drain;
3980 }
3981 _ => {
3982 unimplemented!("");
3983 }
3984 }
3985 }
3986}
3987
3988impl SseDecode for crate::model::PayOnchainRequest {
3989 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3991 let mut var_address = <String>::sse_decode(deserializer);
3992 let mut var_prepareResponse =
3993 <crate::model::PreparePayOnchainResponse>::sse_decode(deserializer);
3994 return crate::model::PayOnchainRequest {
3995 address: var_address,
3996 prepare_response: var_prepareResponse,
3997 };
3998 }
3999}
4000
4001impl SseDecode for crate::model::Payment {
4002 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4004 let mut var_destination = <Option<String>>::sse_decode(deserializer);
4005 let mut var_txId = <Option<String>>::sse_decode(deserializer);
4006 let mut var_unblindingData = <Option<String>>::sse_decode(deserializer);
4007 let mut var_timestamp = <u32>::sse_decode(deserializer);
4008 let mut var_amountSat = <u64>::sse_decode(deserializer);
4009 let mut var_feesSat = <u64>::sse_decode(deserializer);
4010 let mut var_swapperFeesSat = <Option<u64>>::sse_decode(deserializer);
4011 let mut var_paymentType = <crate::model::PaymentType>::sse_decode(deserializer);
4012 let mut var_status = <crate::model::PaymentState>::sse_decode(deserializer);
4013 let mut var_details = <crate::model::PaymentDetails>::sse_decode(deserializer);
4014 return crate::model::Payment {
4015 destination: var_destination,
4016 tx_id: var_txId,
4017 unblinding_data: var_unblindingData,
4018 timestamp: var_timestamp,
4019 amount_sat: var_amountSat,
4020 fees_sat: var_feesSat,
4021 swapper_fees_sat: var_swapperFeesSat,
4022 payment_type: var_paymentType,
4023 status: var_status,
4024 details: var_details,
4025 };
4026 }
4027}
4028
4029impl SseDecode for crate::model::PaymentDetails {
4030 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4032 let mut tag_ = <i32>::sse_decode(deserializer);
4033 match tag_ {
4034 0 => {
4035 let mut var_swapId = <String>::sse_decode(deserializer);
4036 let mut var_description = <String>::sse_decode(deserializer);
4037 let mut var_liquidExpirationBlockheight = <u32>::sse_decode(deserializer);
4038 let mut var_preimage = <Option<String>>::sse_decode(deserializer);
4039 let mut var_invoice = <Option<String>>::sse_decode(deserializer);
4040 let mut var_bolt12Offer = <Option<String>>::sse_decode(deserializer);
4041 let mut var_paymentHash = <Option<String>>::sse_decode(deserializer);
4042 let mut var_destinationPubkey = <Option<String>>::sse_decode(deserializer);
4043 let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4044 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4045 let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4046 let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4047 let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4048 return crate::model::PaymentDetails::Lightning {
4049 swap_id: var_swapId,
4050 description: var_description,
4051 liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4052 preimage: var_preimage,
4053 invoice: var_invoice,
4054 bolt12_offer: var_bolt12Offer,
4055 payment_hash: var_paymentHash,
4056 destination_pubkey: var_destinationPubkey,
4057 lnurl_info: var_lnurlInfo,
4058 bip353_address: var_bip353Address,
4059 claim_tx_id: var_claimTxId,
4060 refund_tx_id: var_refundTxId,
4061 refund_tx_amount_sat: var_refundTxAmountSat,
4062 };
4063 }
4064 1 => {
4065 let mut var_destination = <String>::sse_decode(deserializer);
4066 let mut var_description = <String>::sse_decode(deserializer);
4067 let mut var_assetId = <String>::sse_decode(deserializer);
4068 let mut var_assetInfo = <Option<crate::model::AssetInfo>>::sse_decode(deserializer);
4069 let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4070 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4071 return crate::model::PaymentDetails::Liquid {
4072 destination: var_destination,
4073 description: var_description,
4074 asset_id: var_assetId,
4075 asset_info: var_assetInfo,
4076 lnurl_info: var_lnurlInfo,
4077 bip353_address: var_bip353Address,
4078 };
4079 }
4080 2 => {
4081 let mut var_swapId = <String>::sse_decode(deserializer);
4082 let mut var_bitcoinAddress = <String>::sse_decode(deserializer);
4083 let mut var_description = <String>::sse_decode(deserializer);
4084 let mut var_autoAcceptedFees = <bool>::sse_decode(deserializer);
4085 let mut var_liquidExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4086 let mut var_bitcoinExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4087 let mut var_lockupTxId = <Option<String>>::sse_decode(deserializer);
4088 let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4089 let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4090 let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4091 return crate::model::PaymentDetails::Bitcoin {
4092 swap_id: var_swapId,
4093 bitcoin_address: var_bitcoinAddress,
4094 description: var_description,
4095 auto_accepted_fees: var_autoAcceptedFees,
4096 liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4097 bitcoin_expiration_blockheight: var_bitcoinExpirationBlockheight,
4098 lockup_tx_id: var_lockupTxId,
4099 claim_tx_id: var_claimTxId,
4100 refund_tx_id: var_refundTxId,
4101 refund_tx_amount_sat: var_refundTxAmountSat,
4102 };
4103 }
4104 _ => {
4105 unimplemented!("");
4106 }
4107 }
4108 }
4109}
4110
4111impl SseDecode for crate::error::PaymentError {
4112 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4114 let mut tag_ = <i32>::sse_decode(deserializer);
4115 match tag_ {
4116 0 => {
4117 return crate::error::PaymentError::AlreadyClaimed;
4118 }
4119 1 => {
4120 return crate::error::PaymentError::AlreadyPaid;
4121 }
4122 2 => {
4123 return crate::error::PaymentError::PaymentInProgress;
4124 }
4125 3 => {
4126 let mut var_min = <u64>::sse_decode(deserializer);
4127 let mut var_max = <u64>::sse_decode(deserializer);
4128 return crate::error::PaymentError::AmountOutOfRange {
4129 min: var_min,
4130 max: var_max,
4131 };
4132 }
4133 4 => {
4134 let mut var_err = <String>::sse_decode(deserializer);
4135 return crate::error::PaymentError::AmountMissing { err: var_err };
4136 }
4137 5 => {
4138 let mut var_err = <String>::sse_decode(deserializer);
4139 return crate::error::PaymentError::AssetError { err: var_err };
4140 }
4141 6 => {
4142 let mut var_err = <String>::sse_decode(deserializer);
4143 return crate::error::PaymentError::InvalidNetwork { err: var_err };
4144 }
4145 7 => {
4146 let mut var_err = <String>::sse_decode(deserializer);
4147 return crate::error::PaymentError::Generic { err: var_err };
4148 }
4149 8 => {
4150 return crate::error::PaymentError::InvalidOrExpiredFees;
4151 }
4152 9 => {
4153 return crate::error::PaymentError::InsufficientFunds;
4154 }
4155 10 => {
4156 let mut var_err = <String>::sse_decode(deserializer);
4157 return crate::error::PaymentError::InvalidDescription { err: var_err };
4158 }
4159 11 => {
4160 let mut var_err = <String>::sse_decode(deserializer);
4161 return crate::error::PaymentError::InvalidInvoice { err: var_err };
4162 }
4163 12 => {
4164 return crate::error::PaymentError::InvalidPreimage;
4165 }
4166 13 => {
4167 return crate::error::PaymentError::PairsNotFound;
4168 }
4169 14 => {
4170 return crate::error::PaymentError::PaymentTimeout;
4171 }
4172 15 => {
4173 return crate::error::PaymentError::PersistError;
4174 }
4175 16 => {
4176 let mut var_err = <String>::sse_decode(deserializer);
4177 return crate::error::PaymentError::ReceiveError { err: var_err };
4178 }
4179 17 => {
4180 let mut var_err = <String>::sse_decode(deserializer);
4181 let mut var_refundTxId = <String>::sse_decode(deserializer);
4182 return crate::error::PaymentError::Refunded {
4183 err: var_err,
4184 refund_tx_id: var_refundTxId,
4185 };
4186 }
4187 18 => {
4188 return crate::error::PaymentError::SelfTransferNotSupported;
4189 }
4190 19 => {
4191 let mut var_err = <String>::sse_decode(deserializer);
4192 return crate::error::PaymentError::SendError { err: var_err };
4193 }
4194 20 => {
4195 let mut var_err = <String>::sse_decode(deserializer);
4196 return crate::error::PaymentError::SignerError { err: var_err };
4197 }
4198 _ => {
4199 unimplemented!("");
4200 }
4201 }
4202 }
4203}
4204
4205impl SseDecode for crate::model::PaymentMethod {
4206 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4208 let mut inner = <i32>::sse_decode(deserializer);
4209 return match inner {
4210 0 => crate::model::PaymentMethod::Lightning,
4211 1 => crate::model::PaymentMethod::Bolt11Invoice,
4212 2 => crate::model::PaymentMethod::Bolt12Offer,
4213 3 => crate::model::PaymentMethod::BitcoinAddress,
4214 4 => crate::model::PaymentMethod::LiquidAddress,
4215 _ => unreachable!("Invalid variant for PaymentMethod: {}", inner),
4216 };
4217 }
4218}
4219
4220impl SseDecode for crate::model::PaymentState {
4221 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4223 let mut inner = <i32>::sse_decode(deserializer);
4224 return match inner {
4225 0 => crate::model::PaymentState::Created,
4226 1 => crate::model::PaymentState::Pending,
4227 2 => crate::model::PaymentState::Complete,
4228 3 => crate::model::PaymentState::Failed,
4229 4 => crate::model::PaymentState::TimedOut,
4230 5 => crate::model::PaymentState::Refundable,
4231 6 => crate::model::PaymentState::RefundPending,
4232 7 => crate::model::PaymentState::WaitingFeeAcceptance,
4233 _ => unreachable!("Invalid variant for PaymentState: {}", inner),
4234 };
4235 }
4236}
4237
4238impl SseDecode for crate::model::PaymentType {
4239 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4241 let mut inner = <i32>::sse_decode(deserializer);
4242 return match inner {
4243 0 => crate::model::PaymentType::Receive,
4244 1 => crate::model::PaymentType::Send,
4245 _ => unreachable!("Invalid variant for PaymentType: {}", inner),
4246 };
4247 }
4248}
4249
4250impl SseDecode for crate::model::PrepareBuyBitcoinRequest {
4251 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4253 let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4254 let mut var_amountSat = <u64>::sse_decode(deserializer);
4255 return crate::model::PrepareBuyBitcoinRequest {
4256 provider: var_provider,
4257 amount_sat: var_amountSat,
4258 };
4259 }
4260}
4261
4262impl SseDecode for crate::model::PrepareBuyBitcoinResponse {
4263 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4265 let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4266 let mut var_amountSat = <u64>::sse_decode(deserializer);
4267 let mut var_feesSat = <u64>::sse_decode(deserializer);
4268 return crate::model::PrepareBuyBitcoinResponse {
4269 provider: var_provider,
4270 amount_sat: var_amountSat,
4271 fees_sat: var_feesSat,
4272 };
4273 }
4274}
4275
4276impl SseDecode for crate::model::PrepareLnUrlPayRequest {
4277 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4279 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4280 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4281 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4282 let mut var_comment = <Option<String>>::sse_decode(deserializer);
4283 let mut var_validateSuccessActionUrl = <Option<bool>>::sse_decode(deserializer);
4284 return crate::model::PrepareLnUrlPayRequest {
4285 data: var_data,
4286 amount: var_amount,
4287 bip353_address: var_bip353Address,
4288 comment: var_comment,
4289 validate_success_action_url: var_validateSuccessActionUrl,
4290 };
4291 }
4292}
4293
4294impl SseDecode for crate::model::PrepareLnUrlPayResponse {
4295 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4297 let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4298 let mut var_feesSat = <u64>::sse_decode(deserializer);
4299 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4300 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4301 let mut var_comment = <Option<String>>::sse_decode(deserializer);
4302 let mut var_successAction =
4303 <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
4304 return crate::model::PrepareLnUrlPayResponse {
4305 destination: var_destination,
4306 fees_sat: var_feesSat,
4307 data: var_data,
4308 amount: var_amount,
4309 comment: var_comment,
4310 success_action: var_successAction,
4311 };
4312 }
4313}
4314
4315impl SseDecode for crate::model::PreparePayOnchainRequest {
4316 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4318 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4319 let mut var_feeRateSatPerVbyte = <Option<u32>>::sse_decode(deserializer);
4320 return crate::model::PreparePayOnchainRequest {
4321 amount: var_amount,
4322 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4323 };
4324 }
4325}
4326
4327impl SseDecode for crate::model::PreparePayOnchainResponse {
4328 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4330 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4331 let mut var_claimFeesSat = <u64>::sse_decode(deserializer);
4332 let mut var_totalFeesSat = <u64>::sse_decode(deserializer);
4333 return crate::model::PreparePayOnchainResponse {
4334 receiver_amount_sat: var_receiverAmountSat,
4335 claim_fees_sat: var_claimFeesSat,
4336 total_fees_sat: var_totalFeesSat,
4337 };
4338 }
4339}
4340
4341impl SseDecode for crate::model::PrepareReceiveRequest {
4342 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4344 let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4345 let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4346 return crate::model::PrepareReceiveRequest {
4347 payment_method: var_paymentMethod,
4348 amount: var_amount,
4349 };
4350 }
4351}
4352
4353impl SseDecode for crate::model::PrepareReceiveResponse {
4354 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4356 let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4357 let mut var_feesSat = <u64>::sse_decode(deserializer);
4358 let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4359 let mut var_minPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4360 let mut var_maxPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4361 let mut var_swapperFeerate = <Option<f64>>::sse_decode(deserializer);
4362 return crate::model::PrepareReceiveResponse {
4363 payment_method: var_paymentMethod,
4364 fees_sat: var_feesSat,
4365 amount: var_amount,
4366 min_payer_amount_sat: var_minPayerAmountSat,
4367 max_payer_amount_sat: var_maxPayerAmountSat,
4368 swapper_feerate: var_swapperFeerate,
4369 };
4370 }
4371}
4372
4373impl SseDecode for crate::model::PrepareRefundRequest {
4374 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4376 let mut var_swapAddress = <String>::sse_decode(deserializer);
4377 let mut var_refundAddress = <String>::sse_decode(deserializer);
4378 let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4379 return crate::model::PrepareRefundRequest {
4380 swap_address: var_swapAddress,
4381 refund_address: var_refundAddress,
4382 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4383 };
4384 }
4385}
4386
4387impl SseDecode for crate::model::PrepareRefundResponse {
4388 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4390 let mut var_txVsize = <u32>::sse_decode(deserializer);
4391 let mut var_txFeeSat = <u64>::sse_decode(deserializer);
4392 let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4393 return crate::model::PrepareRefundResponse {
4394 tx_vsize: var_txVsize,
4395 tx_fee_sat: var_txFeeSat,
4396 last_refund_tx_id: var_lastRefundTxId,
4397 };
4398 }
4399}
4400
4401impl SseDecode for crate::model::PrepareSendRequest {
4402 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4404 let mut var_destination = <String>::sse_decode(deserializer);
4405 let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4406 let mut var_comment = <Option<String>>::sse_decode(deserializer);
4407 return crate::model::PrepareSendRequest {
4408 destination: var_destination,
4409 amount: var_amount,
4410 comment: var_comment,
4411 };
4412 }
4413}
4414
4415impl SseDecode for crate::model::PrepareSendResponse {
4416 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4418 let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4419 let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4420 let mut var_feesSat = <Option<u64>>::sse_decode(deserializer);
4421 let mut var_estimatedAssetFees = <Option<f64>>::sse_decode(deserializer);
4422 return crate::model::PrepareSendResponse {
4423 destination: var_destination,
4424 amount: var_amount,
4425 fees_sat: var_feesSat,
4426 estimated_asset_fees: var_estimatedAssetFees,
4427 };
4428 }
4429}
4430
4431impl SseDecode for crate::bindings::Rate {
4432 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4434 let mut var_coin = <String>::sse_decode(deserializer);
4435 let mut var_value = <f64>::sse_decode(deserializer);
4436 return crate::bindings::Rate {
4437 coin: var_coin,
4438 value: var_value,
4439 };
4440 }
4441}
4442
4443impl SseDecode for crate::model::ReceiveAmount {
4444 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4446 let mut tag_ = <i32>::sse_decode(deserializer);
4447 match tag_ {
4448 0 => {
4449 let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
4450 return crate::model::ReceiveAmount::Bitcoin {
4451 payer_amount_sat: var_payerAmountSat,
4452 };
4453 }
4454 1 => {
4455 let mut var_assetId = <String>::sse_decode(deserializer);
4456 let mut var_payerAmount = <Option<f64>>::sse_decode(deserializer);
4457 return crate::model::ReceiveAmount::Asset {
4458 asset_id: var_assetId,
4459 payer_amount: var_payerAmount,
4460 };
4461 }
4462 _ => {
4463 unimplemented!("");
4464 }
4465 }
4466 }
4467}
4468
4469impl SseDecode for crate::model::ReceivePaymentRequest {
4470 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4472 let mut var_prepareResponse =
4473 <crate::model::PrepareReceiveResponse>::sse_decode(deserializer);
4474 let mut var_description = <Option<String>>::sse_decode(deserializer);
4475 let mut var_useDescriptionHash = <Option<bool>>::sse_decode(deserializer);
4476 return crate::model::ReceivePaymentRequest {
4477 prepare_response: var_prepareResponse,
4478 description: var_description,
4479 use_description_hash: var_useDescriptionHash,
4480 };
4481 }
4482}
4483
4484impl SseDecode for crate::model::ReceivePaymentResponse {
4485 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4487 let mut var_destination = <String>::sse_decode(deserializer);
4488 return crate::model::ReceivePaymentResponse {
4489 destination: var_destination,
4490 };
4491 }
4492}
4493
4494impl SseDecode for crate::model::RecommendedFees {
4495 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4497 let mut var_fastestFee = <u64>::sse_decode(deserializer);
4498 let mut var_halfHourFee = <u64>::sse_decode(deserializer);
4499 let mut var_hourFee = <u64>::sse_decode(deserializer);
4500 let mut var_economyFee = <u64>::sse_decode(deserializer);
4501 let mut var_minimumFee = <u64>::sse_decode(deserializer);
4502 return crate::model::RecommendedFees {
4503 fastest_fee: var_fastestFee,
4504 half_hour_fee: var_halfHourFee,
4505 hour_fee: var_hourFee,
4506 economy_fee: var_economyFee,
4507 minimum_fee: var_minimumFee,
4508 };
4509 }
4510}
4511
4512impl SseDecode for crate::model::RefundRequest {
4513 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4515 let mut var_swapAddress = <String>::sse_decode(deserializer);
4516 let mut var_refundAddress = <String>::sse_decode(deserializer);
4517 let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4518 return crate::model::RefundRequest {
4519 swap_address: var_swapAddress,
4520 refund_address: var_refundAddress,
4521 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4522 };
4523 }
4524}
4525
4526impl SseDecode for crate::model::RefundResponse {
4527 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4529 let mut var_refundTxId = <String>::sse_decode(deserializer);
4530 return crate::model::RefundResponse {
4531 refund_tx_id: var_refundTxId,
4532 };
4533 }
4534}
4535
4536impl SseDecode for crate::model::RefundableSwap {
4537 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4539 let mut var_swapAddress = <String>::sse_decode(deserializer);
4540 let mut var_timestamp = <u32>::sse_decode(deserializer);
4541 let mut var_amountSat = <u64>::sse_decode(deserializer);
4542 let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4543 return crate::model::RefundableSwap {
4544 swap_address: var_swapAddress,
4545 timestamp: var_timestamp,
4546 amount_sat: var_amountSat,
4547 last_refund_tx_id: var_lastRefundTxId,
4548 };
4549 }
4550}
4551
4552impl SseDecode for crate::model::RestoreRequest {
4553 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4555 let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
4556 return crate::model::RestoreRequest {
4557 backup_path: var_backupPath,
4558 };
4559 }
4560}
4561
4562impl SseDecode for crate::bindings::RouteHint {
4563 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4565 let mut var_hops = <Vec<crate::bindings::RouteHintHop>>::sse_decode(deserializer);
4566 return crate::bindings::RouteHint { hops: var_hops };
4567 }
4568}
4569
4570impl SseDecode for crate::bindings::RouteHintHop {
4571 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4573 let mut var_srcNodeId = <String>::sse_decode(deserializer);
4574 let mut var_shortChannelId = <String>::sse_decode(deserializer);
4575 let mut var_feesBaseMsat = <u32>::sse_decode(deserializer);
4576 let mut var_feesProportionalMillionths = <u32>::sse_decode(deserializer);
4577 let mut var_cltvExpiryDelta = <u64>::sse_decode(deserializer);
4578 let mut var_htlcMinimumMsat = <Option<u64>>::sse_decode(deserializer);
4579 let mut var_htlcMaximumMsat = <Option<u64>>::sse_decode(deserializer);
4580 return crate::bindings::RouteHintHop {
4581 src_node_id: var_srcNodeId,
4582 short_channel_id: var_shortChannelId,
4583 fees_base_msat: var_feesBaseMsat,
4584 fees_proportional_millionths: var_feesProportionalMillionths,
4585 cltv_expiry_delta: var_cltvExpiryDelta,
4586 htlc_minimum_msat: var_htlcMinimumMsat,
4587 htlc_maximum_msat: var_htlcMaximumMsat,
4588 };
4589 }
4590}
4591
4592impl SseDecode for crate::error::SdkError {
4593 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4595 let mut tag_ = <i32>::sse_decode(deserializer);
4596 match tag_ {
4597 0 => {
4598 return crate::error::SdkError::AlreadyStarted;
4599 }
4600 1 => {
4601 let mut var_err = <String>::sse_decode(deserializer);
4602 return crate::error::SdkError::Generic { err: var_err };
4603 }
4604 2 => {
4605 return crate::error::SdkError::NotStarted;
4606 }
4607 3 => {
4608 let mut var_err = <String>::sse_decode(deserializer);
4609 return crate::error::SdkError::ServiceConnectivity { err: var_err };
4610 }
4611 _ => {
4612 unimplemented!("");
4613 }
4614 }
4615 }
4616}
4617
4618impl SseDecode for crate::model::SdkEvent {
4619 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4621 let mut tag_ = <i32>::sse_decode(deserializer);
4622 match tag_ {
4623 0 => {
4624 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4625 return crate::model::SdkEvent::PaymentFailed {
4626 details: var_details,
4627 };
4628 }
4629 1 => {
4630 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4631 return crate::model::SdkEvent::PaymentPending {
4632 details: var_details,
4633 };
4634 }
4635 2 => {
4636 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4637 return crate::model::SdkEvent::PaymentRefundable {
4638 details: var_details,
4639 };
4640 }
4641 3 => {
4642 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4643 return crate::model::SdkEvent::PaymentRefunded {
4644 details: var_details,
4645 };
4646 }
4647 4 => {
4648 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4649 return crate::model::SdkEvent::PaymentRefundPending {
4650 details: var_details,
4651 };
4652 }
4653 5 => {
4654 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4655 return crate::model::SdkEvent::PaymentSucceeded {
4656 details: var_details,
4657 };
4658 }
4659 6 => {
4660 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4661 return crate::model::SdkEvent::PaymentWaitingConfirmation {
4662 details: var_details,
4663 };
4664 }
4665 7 => {
4666 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4667 return crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
4668 details: var_details,
4669 };
4670 }
4671 8 => {
4672 return crate::model::SdkEvent::Synced;
4673 }
4674 9 => {
4675 let mut var_didPullNewRecords = <bool>::sse_decode(deserializer);
4676 return crate::model::SdkEvent::DataSynced {
4677 did_pull_new_records: var_didPullNewRecords,
4678 };
4679 }
4680 _ => {
4681 unimplemented!("");
4682 }
4683 }
4684 }
4685}
4686
4687impl SseDecode for crate::model::SendDestination {
4688 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4690 let mut tag_ = <i32>::sse_decode(deserializer);
4691 match tag_ {
4692 0 => {
4693 let mut var_addressData =
4694 <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
4695 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4696 return crate::model::SendDestination::LiquidAddress {
4697 address_data: var_addressData,
4698 bip353_address: var_bip353Address,
4699 };
4700 }
4701 1 => {
4702 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
4703 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4704 return crate::model::SendDestination::Bolt11 {
4705 invoice: var_invoice,
4706 bip353_address: var_bip353Address,
4707 };
4708 }
4709 2 => {
4710 let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
4711 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4712 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4713 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4714 return crate::model::SendDestination::Bolt12 {
4715 offer: var_offer,
4716 receiver_amount_sat: var_receiverAmountSat,
4717 bip353_address: var_bip353Address,
4718 payer_note: var_payerNote,
4719 };
4720 }
4721 _ => {
4722 unimplemented!("");
4723 }
4724 }
4725 }
4726}
4727
4728impl SseDecode for crate::model::SendPaymentRequest {
4729 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4731 let mut var_prepareResponse = <crate::model::PrepareSendResponse>::sse_decode(deserializer);
4732 let mut var_useAssetFees = <Option<bool>>::sse_decode(deserializer);
4733 return crate::model::SendPaymentRequest {
4734 prepare_response: var_prepareResponse,
4735 use_asset_fees: var_useAssetFees,
4736 };
4737 }
4738}
4739
4740impl SseDecode for crate::model::SendPaymentResponse {
4741 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4743 let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
4744 return crate::model::SendPaymentResponse {
4745 payment: var_payment,
4746 };
4747 }
4748}
4749
4750impl SseDecode for crate::model::SignMessageRequest {
4751 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4753 let mut var_message = <String>::sse_decode(deserializer);
4754 return crate::model::SignMessageRequest {
4755 message: var_message,
4756 };
4757 }
4758}
4759
4760impl SseDecode for crate::model::SignMessageResponse {
4761 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4763 let mut var_signature = <String>::sse_decode(deserializer);
4764 return crate::model::SignMessageResponse {
4765 signature: var_signature,
4766 };
4767 }
4768}
4769
4770impl SseDecode for crate::bindings::SuccessAction {
4771 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4773 let mut tag_ = <i32>::sse_decode(deserializer);
4774 match tag_ {
4775 0 => {
4776 let mut var_data =
4777 <crate::bindings::AesSuccessActionData>::sse_decode(deserializer);
4778 return crate::bindings::SuccessAction::Aes { data: var_data };
4779 }
4780 1 => {
4781 let mut var_data =
4782 <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4783 return crate::bindings::SuccessAction::Message { data: var_data };
4784 }
4785 2 => {
4786 let mut var_data =
4787 <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4788 return crate::bindings::SuccessAction::Url { data: var_data };
4789 }
4790 _ => {
4791 unimplemented!("");
4792 }
4793 }
4794 }
4795}
4796
4797impl SseDecode for crate::bindings::SuccessActionProcessed {
4798 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4800 let mut tag_ = <i32>::sse_decode(deserializer);
4801 match tag_ {
4802 0 => {
4803 let mut var_result =
4804 <crate::bindings::AesSuccessActionDataResult>::sse_decode(deserializer);
4805 return crate::bindings::SuccessActionProcessed::Aes { result: var_result };
4806 }
4807 1 => {
4808 let mut var_data =
4809 <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4810 return crate::bindings::SuccessActionProcessed::Message { data: var_data };
4811 }
4812 2 => {
4813 let mut var_data =
4814 <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4815 return crate::bindings::SuccessActionProcessed::Url { data: var_data };
4816 }
4817 _ => {
4818 unimplemented!("");
4819 }
4820 }
4821 }
4822}
4823
4824impl SseDecode for crate::bindings::Symbol {
4825 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4827 let mut var_grapheme = <Option<String>>::sse_decode(deserializer);
4828 let mut var_template = <Option<String>>::sse_decode(deserializer);
4829 let mut var_rtl = <Option<bool>>::sse_decode(deserializer);
4830 let mut var_position = <Option<u32>>::sse_decode(deserializer);
4831 return crate::bindings::Symbol {
4832 grapheme: var_grapheme,
4833 template: var_template,
4834 rtl: var_rtl,
4835 position: var_position,
4836 };
4837 }
4838}
4839
4840impl SseDecode for u16 {
4841 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4843 deserializer.cursor.read_u16::<NativeEndian>().unwrap()
4844 }
4845}
4846
4847impl SseDecode for u32 {
4848 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4850 deserializer.cursor.read_u32::<NativeEndian>().unwrap()
4851 }
4852}
4853
4854impl SseDecode for u64 {
4855 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4857 deserializer.cursor.read_u64::<NativeEndian>().unwrap()
4858 }
4859}
4860
4861impl SseDecode for u8 {
4862 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4864 deserializer.cursor.read_u8().unwrap()
4865 }
4866}
4867
4868impl SseDecode for () {
4869 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
4871}
4872
4873impl SseDecode for crate::bindings::UrlSuccessActionData {
4874 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4876 let mut var_description = <String>::sse_decode(deserializer);
4877 let mut var_url = <String>::sse_decode(deserializer);
4878 let mut var_matchesCallbackDomain = <bool>::sse_decode(deserializer);
4879 return crate::bindings::UrlSuccessActionData {
4880 description: var_description,
4881 url: var_url,
4882 matches_callback_domain: var_matchesCallbackDomain,
4883 };
4884 }
4885}
4886
4887impl SseDecode for usize {
4888 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4890 deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
4891 }
4892}
4893
4894impl SseDecode for crate::model::WalletInfo {
4895 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4897 let mut var_balanceSat = <u64>::sse_decode(deserializer);
4898 let mut var_pendingSendSat = <u64>::sse_decode(deserializer);
4899 let mut var_pendingReceiveSat = <u64>::sse_decode(deserializer);
4900 let mut var_fingerprint = <String>::sse_decode(deserializer);
4901 let mut var_pubkey = <String>::sse_decode(deserializer);
4902 let mut var_assetBalances = <Vec<crate::model::AssetBalance>>::sse_decode(deserializer);
4903 return crate::model::WalletInfo {
4904 balance_sat: var_balanceSat,
4905 pending_send_sat: var_pendingSendSat,
4906 pending_receive_sat: var_pendingReceiveSat,
4907 fingerprint: var_fingerprint,
4908 pubkey: var_pubkey,
4909 asset_balances: var_assetBalances,
4910 };
4911 }
4912}
4913
4914fn pde_ffi_dispatcher_primary_impl(
4915 func_id: i32,
4916 port: flutter_rust_bridge::for_generated::MessagePort,
4917 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4918 rust_vec_len: i32,
4919 data_len: i32,
4920) {
4921 match func_id {
4923 _ => unreachable!(),
4924 }
4925}
4926
4927fn pde_ffi_dispatcher_sync_impl(
4928 func_id: i32,
4929 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4930 rust_vec_len: i32,
4931 data_len: i32,
4932) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
4933 match func_id {
4935 _ => unreachable!(),
4936 }
4937}
4938
4939impl flutter_rust_bridge::IntoDart for FrbWrapper<BindingLiquidSdk> {
4943 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4944 flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0)
4945 .into_dart()
4946 }
4947}
4948impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<BindingLiquidSdk> {}
4949
4950impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<BindingLiquidSdk>> for BindingLiquidSdk {
4951 fn into_into_dart(self) -> FrbWrapper<BindingLiquidSdk> {
4952 self.into()
4953 }
4954}
4955
4956impl flutter_rust_bridge::IntoDart for crate::model::AcceptPaymentProposedFeesRequest {
4958 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4959 [self.response.into_into_dart().into_dart()].into_dart()
4960 }
4961}
4962impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4963 for crate::model::AcceptPaymentProposedFeesRequest
4964{
4965}
4966impl flutter_rust_bridge::IntoIntoDart<crate::model::AcceptPaymentProposedFeesRequest>
4967 for crate::model::AcceptPaymentProposedFeesRequest
4968{
4969 fn into_into_dart(self) -> crate::model::AcceptPaymentProposedFeesRequest {
4970 self
4971 }
4972}
4973impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionData> {
4975 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4976 [
4977 self.0.description.into_into_dart().into_dart(),
4978 self.0.ciphertext.into_into_dart().into_dart(),
4979 self.0.iv.into_into_dart().into_dart(),
4980 ]
4981 .into_dart()
4982 }
4983}
4984impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4985 for FrbWrapper<crate::bindings::AesSuccessActionData>
4986{
4987}
4988impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionData>>
4989 for crate::bindings::AesSuccessActionData
4990{
4991 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionData> {
4992 self.into()
4993 }
4994}
4995impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
4997 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4998 [
4999 self.0.description.into_into_dart().into_dart(),
5000 self.0.plaintext.into_into_dart().into_dart(),
5001 ]
5002 .into_dart()
5003 }
5004}
5005impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5006 for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>
5007{
5008}
5009impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>>
5010 for crate::bindings::AesSuccessActionDataDecrypted
5011{
5012 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5013 self.into()
5014 }
5015}
5016impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5018 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5019 match self.0 {
5020 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
5021 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
5022 }
5023 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
5024 [1.into_dart(), reason.into_into_dart().into_dart()].into_dart()
5025 }
5026 _ => {
5027 unimplemented!("");
5028 }
5029 }
5030 }
5031}
5032impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5033 for FrbWrapper<crate::bindings::AesSuccessActionDataResult>
5034{
5035}
5036impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataResult>>
5037 for crate::bindings::AesSuccessActionDataResult
5038{
5039 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5040 self.into()
5041 }
5042}
5043impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Amount> {
5045 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5046 match self.0 {
5047 crate::bindings::Amount::Bitcoin { amount_msat } => {
5048 [0.into_dart(), amount_msat.into_into_dart().into_dart()].into_dart()
5049 }
5050 crate::bindings::Amount::Currency {
5051 iso4217_code,
5052 fractional_amount,
5053 } => [
5054 1.into_dart(),
5055 iso4217_code.into_into_dart().into_dart(),
5056 fractional_amount.into_into_dart().into_dart(),
5057 ]
5058 .into_dart(),
5059 _ => {
5060 unimplemented!("");
5061 }
5062 }
5063 }
5064}
5065impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5066 for FrbWrapper<crate::bindings::Amount>
5067{
5068}
5069impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Amount>>
5070 for crate::bindings::Amount
5071{
5072 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Amount> {
5073 self.into()
5074 }
5075}
5076impl flutter_rust_bridge::IntoDart for crate::model::AssetBalance {
5078 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5079 [
5080 self.asset_id.into_into_dart().into_dart(),
5081 self.balance_sat.into_into_dart().into_dart(),
5082 self.name.into_into_dart().into_dart(),
5083 self.ticker.into_into_dart().into_dart(),
5084 self.balance.into_into_dart().into_dart(),
5085 ]
5086 .into_dart()
5087 }
5088}
5089impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetBalance {}
5090impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetBalance> for crate::model::AssetBalance {
5091 fn into_into_dart(self) -> crate::model::AssetBalance {
5092 self
5093 }
5094}
5095impl flutter_rust_bridge::IntoDart for crate::model::AssetInfo {
5097 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5098 [
5099 self.name.into_into_dart().into_dart(),
5100 self.ticker.into_into_dart().into_dart(),
5101 self.amount.into_into_dart().into_dart(),
5102 self.fees.into_into_dart().into_dart(),
5103 ]
5104 .into_dart()
5105 }
5106}
5107impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetInfo {}
5108impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetInfo> for crate::model::AssetInfo {
5109 fn into_into_dart(self) -> crate::model::AssetInfo {
5110 self
5111 }
5112}
5113impl flutter_rust_bridge::IntoDart for crate::model::AssetMetadata {
5115 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5116 [
5117 self.asset_id.into_into_dart().into_dart(),
5118 self.name.into_into_dart().into_dart(),
5119 self.ticker.into_into_dart().into_dart(),
5120 self.precision.into_into_dart().into_dart(),
5121 self.fiat_id.into_into_dart().into_dart(),
5122 ]
5123 .into_dart()
5124 }
5125}
5126impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetMetadata {}
5127impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetMetadata>
5128 for crate::model::AssetMetadata
5129{
5130 fn into_into_dart(self) -> crate::model::AssetMetadata {
5131 self
5132 }
5133}
5134impl flutter_rust_bridge::IntoDart for crate::model::BackupRequest {
5136 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5137 [self.backup_path.into_into_dart().into_dart()].into_dart()
5138 }
5139}
5140impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BackupRequest {}
5141impl flutter_rust_bridge::IntoIntoDart<crate::model::BackupRequest>
5142 for crate::model::BackupRequest
5143{
5144 fn into_into_dart(self) -> crate::model::BackupRequest {
5145 self
5146 }
5147}
5148impl flutter_rust_bridge::IntoDart for crate::bindings::BindingEventListener {
5150 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5151 [self.stream.into_into_dart().into_dart()].into_dart()
5152 }
5153}
5154impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5155 for crate::bindings::BindingEventListener
5156{
5157}
5158impl flutter_rust_bridge::IntoIntoDart<crate::bindings::BindingEventListener>
5159 for crate::bindings::BindingEventListener
5160{
5161 fn into_into_dart(self) -> crate::bindings::BindingEventListener {
5162 self
5163 }
5164}
5165impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::BitcoinAddressData> {
5167 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5168 [
5169 self.0.address.into_into_dart().into_dart(),
5170 self.0.network.into_into_dart().into_dart(),
5171 self.0.amount_sat.into_into_dart().into_dart(),
5172 self.0.label.into_into_dart().into_dart(),
5173 self.0.message.into_into_dart().into_dart(),
5174 ]
5175 .into_dart()
5176 }
5177}
5178impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5179 for FrbWrapper<crate::bindings::BitcoinAddressData>
5180{
5181}
5182impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::BitcoinAddressData>>
5183 for crate::bindings::BitcoinAddressData
5184{
5185 fn into_into_dart(self) -> FrbWrapper<crate::bindings::BitcoinAddressData> {
5186 self.into()
5187 }
5188}
5189impl flutter_rust_bridge::IntoDart for crate::model::BlockchainExplorer {
5191 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5192 match self {
5193 crate::model::BlockchainExplorer::Electrum { url } => {
5194 [0.into_dart(), url.into_into_dart().into_dart()].into_dart()
5195 }
5196 crate::model::BlockchainExplorer::Esplora {
5197 url,
5198 use_waterfalls,
5199 } => [
5200 1.into_dart(),
5201 url.into_into_dart().into_dart(),
5202 use_waterfalls.into_into_dart().into_dart(),
5203 ]
5204 .into_dart(),
5205 _ => {
5206 unimplemented!("");
5207 }
5208 }
5209 }
5210}
5211impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5212 for crate::model::BlockchainExplorer
5213{
5214}
5215impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainExplorer>
5216 for crate::model::BlockchainExplorer
5217{
5218 fn into_into_dart(self) -> crate::model::BlockchainExplorer {
5219 self
5220 }
5221}
5222impl flutter_rust_bridge::IntoDart for crate::model::BlockchainInfo {
5224 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5225 [
5226 self.liquid_tip.into_into_dart().into_dart(),
5227 self.bitcoin_tip.into_into_dart().into_dart(),
5228 ]
5229 .into_dart()
5230 }
5231}
5232impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BlockchainInfo {}
5233impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainInfo>
5234 for crate::model::BlockchainInfo
5235{
5236 fn into_into_dart(self) -> crate::model::BlockchainInfo {
5237 self
5238 }
5239}
5240impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinProvider {
5242 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5243 match self {
5244 Self::Moonpay => 0.into_dart(),
5245 _ => unreachable!(),
5246 }
5247 }
5248}
5249impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5250 for crate::model::BuyBitcoinProvider
5251{
5252}
5253impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinProvider>
5254 for crate::model::BuyBitcoinProvider
5255{
5256 fn into_into_dart(self) -> crate::model::BuyBitcoinProvider {
5257 self
5258 }
5259}
5260impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinRequest {
5262 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5263 [
5264 self.prepare_response.into_into_dart().into_dart(),
5265 self.redirect_url.into_into_dart().into_dart(),
5266 ]
5267 .into_dart()
5268 }
5269}
5270impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5271 for crate::model::BuyBitcoinRequest
5272{
5273}
5274impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinRequest>
5275 for crate::model::BuyBitcoinRequest
5276{
5277 fn into_into_dart(self) -> crate::model::BuyBitcoinRequest {
5278 self
5279 }
5280}
5281impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageRequest {
5283 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5284 [
5285 self.message.into_into_dart().into_dart(),
5286 self.pubkey.into_into_dart().into_dart(),
5287 self.signature.into_into_dart().into_dart(),
5288 ]
5289 .into_dart()
5290 }
5291}
5292impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5293 for crate::model::CheckMessageRequest
5294{
5295}
5296impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageRequest>
5297 for crate::model::CheckMessageRequest
5298{
5299 fn into_into_dart(self) -> crate::model::CheckMessageRequest {
5300 self
5301 }
5302}
5303impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageResponse {
5305 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5306 [self.is_valid.into_into_dart().into_dart()].into_dart()
5307 }
5308}
5309impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5310 for crate::model::CheckMessageResponse
5311{
5312}
5313impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageResponse>
5314 for crate::model::CheckMessageResponse
5315{
5316 fn into_into_dart(self) -> crate::model::CheckMessageResponse {
5317 self
5318 }
5319}
5320impl flutter_rust_bridge::IntoDart for crate::model::Config {
5322 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5323 [
5324 self.liquid_explorer.into_into_dart().into_dart(),
5325 self.bitcoin_explorer.into_into_dart().into_dart(),
5326 self.working_dir.into_into_dart().into_dart(),
5327 self.network.into_into_dart().into_dart(),
5328 self.payment_timeout_sec.into_into_dart().into_dart(),
5329 self.sync_service_url.into_into_dart().into_dart(),
5330 self.zero_conf_max_amount_sat.into_into_dart().into_dart(),
5331 self.breez_api_key.into_into_dart().into_dart(),
5332 self.external_input_parsers.into_into_dart().into_dart(),
5333 self.use_default_external_input_parsers
5334 .into_into_dart()
5335 .into_dart(),
5336 self.onchain_fee_rate_leeway_sat_per_vbyte
5337 .into_into_dart()
5338 .into_dart(),
5339 self.asset_metadata.into_into_dart().into_dart(),
5340 self.sideswap_api_key.into_into_dart().into_dart(),
5341 ]
5342 .into_dart()
5343 }
5344}
5345impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Config {}
5346impl flutter_rust_bridge::IntoIntoDart<crate::model::Config> for crate::model::Config {
5347 fn into_into_dart(self) -> crate::model::Config {
5348 self
5349 }
5350}
5351impl flutter_rust_bridge::IntoDart for crate::model::ConnectRequest {
5353 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5354 [
5355 self.config.into_into_dart().into_dart(),
5356 self.mnemonic.into_into_dart().into_dart(),
5357 self.passphrase.into_into_dart().into_dart(),
5358 self.seed.into_into_dart().into_dart(),
5359 ]
5360 .into_dart()
5361 }
5362}
5363impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ConnectRequest {}
5364impl flutter_rust_bridge::IntoIntoDart<crate::model::ConnectRequest>
5365 for crate::model::ConnectRequest
5366{
5367 fn into_into_dart(self) -> crate::model::ConnectRequest {
5368 self
5369 }
5370}
5371impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceRequest {
5373 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5374 [
5375 self.offer.into_into_dart().into_dart(),
5376 self.invoice_request.into_into_dart().into_dart(),
5377 ]
5378 .into_dart()
5379 }
5380}
5381impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5382 for crate::model::CreateBolt12InvoiceRequest
5383{
5384}
5385impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceRequest>
5386 for crate::model::CreateBolt12InvoiceRequest
5387{
5388 fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceRequest {
5389 self
5390 }
5391}
5392impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceResponse {
5394 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5395 [self.invoice.into_into_dart().into_dart()].into_dart()
5396 }
5397}
5398impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5399 for crate::model::CreateBolt12InvoiceResponse
5400{
5401}
5402impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceResponse>
5403 for crate::model::CreateBolt12InvoiceResponse
5404{
5405 fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceResponse {
5406 self
5407 }
5408}
5409impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::CurrencyInfo> {
5411 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5412 [
5413 self.0.name.into_into_dart().into_dart(),
5414 self.0.fraction_size.into_into_dart().into_dart(),
5415 self.0.spacing.into_into_dart().into_dart(),
5416 self.0.symbol.into_into_dart().into_dart(),
5417 self.0.uniq_symbol.into_into_dart().into_dart(),
5418 self.0.localized_name.into_into_dart().into_dart(),
5419 self.0.locale_overrides.into_into_dart().into_dart(),
5420 ]
5421 .into_dart()
5422 }
5423}
5424impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5425 for FrbWrapper<crate::bindings::CurrencyInfo>
5426{
5427}
5428impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::CurrencyInfo>>
5429 for crate::bindings::CurrencyInfo
5430{
5431 fn into_into_dart(self) -> FrbWrapper<crate::bindings::CurrencyInfo> {
5432 self.into()
5433 }
5434}
5435impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::ExternalInputParser> {
5437 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5438 [
5439 self.0.provider_id.into_into_dart().into_dart(),
5440 self.0.input_regex.into_into_dart().into_dart(),
5441 self.0.parser_url.into_into_dart().into_dart(),
5442 ]
5443 .into_dart()
5444 }
5445}
5446impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5447 for FrbWrapper<crate::bindings::ExternalInputParser>
5448{
5449}
5450impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::ExternalInputParser>>
5451 for crate::bindings::ExternalInputParser
5452{
5453 fn into_into_dart(self) -> FrbWrapper<crate::bindings::ExternalInputParser> {
5454 self.into()
5455 }
5456}
5457impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesRequest {
5459 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5460 [self.swap_id.into_into_dart().into_dart()].into_dart()
5461 }
5462}
5463impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5464 for crate::model::FetchPaymentProposedFeesRequest
5465{
5466}
5467impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesRequest>
5468 for crate::model::FetchPaymentProposedFeesRequest
5469{
5470 fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesRequest {
5471 self
5472 }
5473}
5474impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesResponse {
5476 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5477 [
5478 self.swap_id.into_into_dart().into_dart(),
5479 self.fees_sat.into_into_dart().into_dart(),
5480 self.payer_amount_sat.into_into_dart().into_dart(),
5481 self.receiver_amount_sat.into_into_dart().into_dart(),
5482 ]
5483 .into_dart()
5484 }
5485}
5486impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5487 for crate::model::FetchPaymentProposedFeesResponse
5488{
5489}
5490impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesResponse>
5491 for crate::model::FetchPaymentProposedFeesResponse
5492{
5493 fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesResponse {
5494 self
5495 }
5496}
5497impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::FiatCurrency> {
5499 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5500 [
5501 self.0.id.into_into_dart().into_dart(),
5502 self.0.info.into_into_dart().into_dart(),
5503 ]
5504 .into_dart()
5505 }
5506}
5507impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5508 for FrbWrapper<crate::bindings::FiatCurrency>
5509{
5510}
5511impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::FiatCurrency>>
5512 for crate::bindings::FiatCurrency
5513{
5514 fn into_into_dart(self) -> FrbWrapper<crate::bindings::FiatCurrency> {
5515 self.into()
5516 }
5517}
5518impl flutter_rust_bridge::IntoDart for crate::model::GetInfoResponse {
5520 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5521 [
5522 self.wallet_info.into_into_dart().into_dart(),
5523 self.blockchain_info.into_into_dart().into_dart(),
5524 ]
5525 .into_dart()
5526 }
5527}
5528impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::GetInfoResponse {}
5529impl flutter_rust_bridge::IntoIntoDart<crate::model::GetInfoResponse>
5530 for crate::model::GetInfoResponse
5531{
5532 fn into_into_dart(self) -> crate::model::GetInfoResponse {
5533 self
5534 }
5535}
5536impl flutter_rust_bridge::IntoDart for crate::model::GetPaymentRequest {
5538 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5539 match self {
5540 crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
5541 [0.into_dart(), payment_hash.into_into_dart().into_dart()].into_dart()
5542 }
5543 crate::model::GetPaymentRequest::SwapId { swap_id } => {
5544 [1.into_dart(), swap_id.into_into_dart().into_dart()].into_dart()
5545 }
5546 _ => {
5547 unimplemented!("");
5548 }
5549 }
5550 }
5551}
5552impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5553 for crate::model::GetPaymentRequest
5554{
5555}
5556impl flutter_rust_bridge::IntoIntoDart<crate::model::GetPaymentRequest>
5557 for crate::model::GetPaymentRequest
5558{
5559 fn into_into_dart(self) -> crate::model::GetPaymentRequest {
5560 self
5561 }
5562}
5563impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::InputType> {
5565 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5566 match self.0 {
5567 crate::bindings::InputType::BitcoinAddress { address } => {
5568 [0.into_dart(), address.into_into_dart().into_dart()].into_dart()
5569 }
5570 crate::bindings::InputType::LiquidAddress { address } => {
5571 [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5572 }
5573 crate::bindings::InputType::Bolt11 { invoice } => {
5574 [2.into_dart(), invoice.into_into_dart().into_dart()].into_dart()
5575 }
5576 crate::bindings::InputType::Bolt12Offer {
5577 offer,
5578 bip353_address,
5579 } => [
5580 3.into_dart(),
5581 offer.into_into_dart().into_dart(),
5582 bip353_address.into_into_dart().into_dart(),
5583 ]
5584 .into_dart(),
5585 crate::bindings::InputType::NodeId { node_id } => {
5586 [4.into_dart(), node_id.into_into_dart().into_dart()].into_dart()
5587 }
5588 crate::bindings::InputType::Url { url } => {
5589 [5.into_dart(), url.into_into_dart().into_dart()].into_dart()
5590 }
5591 crate::bindings::InputType::LnUrlPay {
5592 data,
5593 bip353_address,
5594 } => [
5595 6.into_dart(),
5596 data.into_into_dart().into_dart(),
5597 bip353_address.into_into_dart().into_dart(),
5598 ]
5599 .into_dart(),
5600 crate::bindings::InputType::LnUrlWithdraw { data } => {
5601 [7.into_dart(), data.into_into_dart().into_dart()].into_dart()
5602 }
5603 crate::bindings::InputType::LnUrlAuth { data } => {
5604 [8.into_dart(), data.into_into_dart().into_dart()].into_dart()
5605 }
5606 crate::bindings::InputType::LnUrlError { data } => {
5607 [9.into_dart(), data.into_into_dart().into_dart()].into_dart()
5608 }
5609 _ => {
5610 unimplemented!("");
5611 }
5612 }
5613 }
5614}
5615impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5616 for FrbWrapper<crate::bindings::InputType>
5617{
5618}
5619impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::InputType>>
5620 for crate::bindings::InputType
5621{
5622 fn into_into_dart(self) -> FrbWrapper<crate::bindings::InputType> {
5623 self.into()
5624 }
5625}
5626impl flutter_rust_bridge::IntoDart for crate::model::LightningPaymentLimitsResponse {
5628 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5629 [
5630 self.send.into_into_dart().into_dart(),
5631 self.receive.into_into_dart().into_dart(),
5632 ]
5633 .into_dart()
5634 }
5635}
5636impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5637 for crate::model::LightningPaymentLimitsResponse
5638{
5639}
5640impl flutter_rust_bridge::IntoIntoDart<crate::model::LightningPaymentLimitsResponse>
5641 for crate::model::LightningPaymentLimitsResponse
5642{
5643 fn into_into_dart(self) -> crate::model::LightningPaymentLimitsResponse {
5644 self
5645 }
5646}
5647impl flutter_rust_bridge::IntoDart for crate::model::Limits {
5649 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5650 [
5651 self.min_sat.into_into_dart().into_dart(),
5652 self.max_sat.into_into_dart().into_dart(),
5653 self.max_zero_conf_sat.into_into_dart().into_dart(),
5654 ]
5655 .into_dart()
5656 }
5657}
5658impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Limits {}
5659impl flutter_rust_bridge::IntoIntoDart<crate::model::Limits> for crate::model::Limits {
5660 fn into_into_dart(self) -> crate::model::Limits {
5661 self
5662 }
5663}
5664impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LiquidAddressData> {
5666 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5667 [
5668 self.0.address.into_into_dart().into_dart(),
5669 self.0.network.into_into_dart().into_dart(),
5670 self.0.asset_id.into_into_dart().into_dart(),
5671 self.0.amount.into_into_dart().into_dart(),
5672 self.0.amount_sat.into_into_dart().into_dart(),
5673 self.0.label.into_into_dart().into_dart(),
5674 self.0.message.into_into_dart().into_dart(),
5675 ]
5676 .into_dart()
5677 }
5678}
5679impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5680 for FrbWrapper<crate::bindings::LiquidAddressData>
5681{
5682}
5683impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LiquidAddressData>>
5684 for crate::bindings::LiquidAddressData
5685{
5686 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LiquidAddressData> {
5687 self.into()
5688 }
5689}
5690impl flutter_rust_bridge::IntoDart for crate::model::LiquidNetwork {
5692 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5693 match self {
5694 Self::Mainnet => 0.into_dart(),
5695 Self::Testnet => 1.into_dart(),
5696 Self::Regtest => 2.into_dart(),
5697 _ => unreachable!(),
5698 }
5699 }
5700}
5701impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LiquidNetwork {}
5702impl flutter_rust_bridge::IntoIntoDart<crate::model::LiquidNetwork>
5703 for crate::model::LiquidNetwork
5704{
5705 fn into_into_dart(self) -> crate::model::LiquidNetwork {
5706 self
5707 }
5708}
5709impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentDetails {
5711 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5712 match self {
5713 crate::model::ListPaymentDetails::Liquid {
5714 asset_id,
5715 destination,
5716 } => [
5717 0.into_dart(),
5718 asset_id.into_into_dart().into_dart(),
5719 destination.into_into_dart().into_dart(),
5720 ]
5721 .into_dart(),
5722 crate::model::ListPaymentDetails::Bitcoin { address } => {
5723 [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5724 }
5725 _ => {
5726 unimplemented!("");
5727 }
5728 }
5729 }
5730}
5731impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5732 for crate::model::ListPaymentDetails
5733{
5734}
5735impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentDetails>
5736 for crate::model::ListPaymentDetails
5737{
5738 fn into_into_dart(self) -> crate::model::ListPaymentDetails {
5739 self
5740 }
5741}
5742impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentsRequest {
5744 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5745 [
5746 self.filters.into_into_dart().into_dart(),
5747 self.states.into_into_dart().into_dart(),
5748 self.from_timestamp.into_into_dart().into_dart(),
5749 self.to_timestamp.into_into_dart().into_dart(),
5750 self.offset.into_into_dart().into_dart(),
5751 self.limit.into_into_dart().into_dart(),
5752 self.details.into_into_dart().into_dart(),
5753 self.sort_ascending.into_into_dart().into_dart(),
5754 ]
5755 .into_dart()
5756 }
5757}
5758impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5759 for crate::model::ListPaymentsRequest
5760{
5761}
5762impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentsRequest>
5763 for crate::model::ListPaymentsRequest
5764{
5765 fn into_into_dart(self) -> crate::model::ListPaymentsRequest {
5766 self
5767 }
5768}
5769impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNInvoice> {
5771 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5772 [
5773 self.0.bolt11.into_into_dart().into_dart(),
5774 self.0.network.into_into_dart().into_dart(),
5775 self.0.payee_pubkey.into_into_dart().into_dart(),
5776 self.0.payment_hash.into_into_dart().into_dart(),
5777 self.0.description.into_into_dart().into_dart(),
5778 self.0.description_hash.into_into_dart().into_dart(),
5779 self.0.amount_msat.into_into_dart().into_dart(),
5780 self.0.timestamp.into_into_dart().into_dart(),
5781 self.0.expiry.into_into_dart().into_dart(),
5782 self.0.routing_hints.into_into_dart().into_dart(),
5783 self.0.payment_secret.into_into_dart().into_dart(),
5784 self.0
5785 .min_final_cltv_expiry_delta
5786 .into_into_dart()
5787 .into_dart(),
5788 ]
5789 .into_dart()
5790 }
5791}
5792impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5793 for FrbWrapper<crate::bindings::LNInvoice>
5794{
5795}
5796impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNInvoice>>
5797 for crate::bindings::LNInvoice
5798{
5799 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNInvoice> {
5800 self.into()
5801 }
5802}
5803impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNOffer> {
5805 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5806 [
5807 self.0.offer.into_into_dart().into_dart(),
5808 self.0.chains.into_into_dart().into_dart(),
5809 self.0.min_amount.into_into_dart().into_dart(),
5810 self.0.description.into_into_dart().into_dart(),
5811 self.0.absolute_expiry.into_into_dart().into_dart(),
5812 self.0.issuer.into_into_dart().into_dart(),
5813 self.0.signing_pubkey.into_into_dart().into_dart(),
5814 self.0.paths.into_into_dart().into_dart(),
5815 ]
5816 .into_dart()
5817 }
5818}
5819impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5820 for FrbWrapper<crate::bindings::LNOffer>
5821{
5822}
5823impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNOffer>>
5824 for crate::bindings::LNOffer
5825{
5826 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNOffer> {
5827 self.into()
5828 }
5829}
5830impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5832 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5833 [self.0.blinded_hops.into_into_dart().into_dart()].into_dart()
5834 }
5835}
5836impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5837 for FrbWrapper<crate::bindings::LnOfferBlindedPath>
5838{
5839}
5840impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnOfferBlindedPath>>
5841 for crate::bindings::LnOfferBlindedPath
5842{
5843 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5844 self.into()
5845 }
5846}
5847impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlAuthError {
5849 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5850 match self {
5851 crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
5852 [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
5853 }
5854 crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
5855 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5856 }
5857 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
5858 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5859 }
5860 _ => {
5861 unimplemented!("");
5862 }
5863 }
5864 }
5865}
5866impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5867 for crate::bindings::duplicates::LnUrlAuthError
5868{
5869}
5870impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlAuthError>
5871 for crate::bindings::duplicates::LnUrlAuthError
5872{
5873 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlAuthError {
5874 self
5875 }
5876}
5877impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5879 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5880 [
5881 self.0.k1.into_into_dart().into_dart(),
5882 self.0.action.into_into_dart().into_dart(),
5883 self.0.domain.into_into_dart().into_dart(),
5884 self.0.url.into_into_dart().into_dart(),
5885 ]
5886 .into_dart()
5887 }
5888}
5889impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5890 for FrbWrapper<crate::bindings::LnUrlAuthRequestData>
5891{
5892}
5893impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlAuthRequestData>>
5894 for crate::bindings::LnUrlAuthRequestData
5895{
5896 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5897 self.into()
5898 }
5899}
5900impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlCallbackStatus {
5902 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5903 match self {
5904 crate::bindings::duplicates::LnUrlCallbackStatus::Ok => [0.into_dart()].into_dart(),
5905 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
5906 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
5907 }
5908 _ => {
5909 unimplemented!("");
5910 }
5911 }
5912 }
5913}
5914impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5915 for crate::bindings::duplicates::LnUrlCallbackStatus
5916{
5917}
5918impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlCallbackStatus>
5919 for crate::bindings::duplicates::LnUrlCallbackStatus
5920{
5921 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
5922 self
5923 }
5924}
5925impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlErrorData> {
5927 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5928 [self.0.reason.into_into_dart().into_dart()].into_dart()
5929 }
5930}
5931impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5932 for FrbWrapper<crate::bindings::LnUrlErrorData>
5933{
5934}
5935impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlErrorData>>
5936 for crate::bindings::LnUrlErrorData
5937{
5938 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlErrorData> {
5939 self.into()
5940 }
5941}
5942impl flutter_rust_bridge::IntoDart for crate::model::LnUrlInfo {
5944 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5945 [
5946 self.ln_address.into_into_dart().into_dart(),
5947 self.lnurl_pay_comment.into_into_dart().into_dart(),
5948 self.lnurl_pay_domain.into_into_dart().into_dart(),
5949 self.lnurl_pay_metadata.into_into_dart().into_dart(),
5950 self.lnurl_pay_success_action.into_into_dart().into_dart(),
5951 self.lnurl_pay_unprocessed_success_action
5952 .into_into_dart()
5953 .into_dart(),
5954 self.lnurl_withdraw_endpoint.into_into_dart().into_dart(),
5955 ]
5956 .into_dart()
5957 }
5958}
5959impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlInfo {}
5960impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlInfo> for crate::model::LnUrlInfo {
5961 fn into_into_dart(self) -> crate::model::LnUrlInfo {
5962 self
5963 }
5964}
5965impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlPayError {
5967 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5968 match self {
5969 crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => [0.into_dart()].into_dart(),
5970 crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
5971 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5972 }
5973 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
5974 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5975 }
5976 crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
5977 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
5978 }
5979 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
5980 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
5981 }
5982 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
5983 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
5984 }
5985 crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
5986 [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
5987 }
5988 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
5989 [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
5990 }
5991 crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
5992 [8.into_dart(), err.into_into_dart().into_dart()].into_dart()
5993 }
5994 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
5995 [9.into_dart(), err.into_into_dart().into_dart()].into_dart()
5996 }
5997 crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
5998 [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
5999 }
6000 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
6001 [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6002 }
6003 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
6004 [12.into_dart(), err.into_into_dart().into_dart()].into_dart()
6005 }
6006 _ => {
6007 unimplemented!("");
6008 }
6009 }
6010 }
6011}
6012impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6013 for crate::bindings::duplicates::LnUrlPayError
6014{
6015}
6016impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlPayError>
6017 for crate::bindings::duplicates::LnUrlPayError
6018{
6019 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlPayError {
6020 self
6021 }
6022}
6023impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6025 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6026 [
6027 self.0.payment_hash.into_into_dart().into_dart(),
6028 self.0.reason.into_into_dart().into_dart(),
6029 ]
6030 .into_dart()
6031 }
6032}
6033impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6034 for FrbWrapper<crate::bindings::LnUrlPayErrorData>
6035{
6036}
6037impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayErrorData>>
6038 for crate::bindings::LnUrlPayErrorData
6039{
6040 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6041 self.into()
6042 }
6043}
6044impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayRequest {
6046 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6047 [self.prepare_response.into_into_dart().into_dart()].into_dart()
6048 }
6049}
6050impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayRequest {}
6051impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayRequest>
6052 for crate::model::LnUrlPayRequest
6053{
6054 fn into_into_dart(self) -> crate::model::LnUrlPayRequest {
6055 self
6056 }
6057}
6058impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6060 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6061 [
6062 self.0.callback.into_into_dart().into_dart(),
6063 self.0.min_sendable.into_into_dart().into_dart(),
6064 self.0.max_sendable.into_into_dart().into_dart(),
6065 self.0.metadata_str.into_into_dart().into_dart(),
6066 self.0.comment_allowed.into_into_dart().into_dart(),
6067 self.0.domain.into_into_dart().into_dart(),
6068 self.0.allows_nostr.into_into_dart().into_dart(),
6069 self.0.nostr_pubkey.into_into_dart().into_dart(),
6070 self.0.ln_address.into_into_dart().into_dart(),
6071 ]
6072 .into_dart()
6073 }
6074}
6075impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6076 for FrbWrapper<crate::bindings::LnUrlPayRequestData>
6077{
6078}
6079impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayRequestData>>
6080 for crate::bindings::LnUrlPayRequestData
6081{
6082 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6083 self.into()
6084 }
6085}
6086impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayResult {
6088 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6089 match self {
6090 crate::model::LnUrlPayResult::EndpointSuccess { data } => {
6091 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6092 }
6093 crate::model::LnUrlPayResult::EndpointError { data } => {
6094 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6095 }
6096 crate::model::LnUrlPayResult::PayError { data } => {
6097 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6098 }
6099 _ => {
6100 unimplemented!("");
6101 }
6102 }
6103 }
6104}
6105impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayResult {}
6106impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayResult>
6107 for crate::model::LnUrlPayResult
6108{
6109 fn into_into_dart(self) -> crate::model::LnUrlPayResult {
6110 self
6111 }
6112}
6113impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPaySuccessData {
6115 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6116 [
6117 self.payment.into_into_dart().into_dart(),
6118 self.success_action.into_into_dart().into_dart(),
6119 ]
6120 .into_dart()
6121 }
6122}
6123impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6124 for crate::model::LnUrlPaySuccessData
6125{
6126}
6127impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPaySuccessData>
6128 for crate::model::LnUrlPaySuccessData
6129{
6130 fn into_into_dart(self) -> crate::model::LnUrlPaySuccessData {
6131 self
6132 }
6133}
6134impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawError {
6136 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6137 match self {
6138 crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
6139 [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
6140 }
6141 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
6142 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
6143 }
6144 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
6145 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
6146 }
6147 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
6148 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
6149 }
6150 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
6151 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6152 }
6153 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
6154 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6155 }
6156 _ => {
6157 unimplemented!("");
6158 }
6159 }
6160 }
6161}
6162impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6163 for crate::bindings::duplicates::LnUrlWithdrawError
6164{
6165}
6166impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawError>
6167 for crate::bindings::duplicates::LnUrlWithdrawError
6168{
6169 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
6170 self
6171 }
6172}
6173impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6175 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6176 [
6177 self.0.data.into_into_dart().into_dart(),
6178 self.0.amount_msat.into_into_dart().into_dart(),
6179 self.0.description.into_into_dart().into_dart(),
6180 ]
6181 .into_dart()
6182 }
6183}
6184impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6185 for FrbWrapper<crate::bindings::LnUrlWithdrawRequest>
6186{
6187}
6188impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequest>>
6189 for crate::bindings::LnUrlWithdrawRequest
6190{
6191 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6192 self.into()
6193 }
6194}
6195impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6197 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6198 [
6199 self.0.callback.into_into_dart().into_dart(),
6200 self.0.k1.into_into_dart().into_dart(),
6201 self.0.default_description.into_into_dart().into_dart(),
6202 self.0.min_withdrawable.into_into_dart().into_dart(),
6203 self.0.max_withdrawable.into_into_dart().into_dart(),
6204 ]
6205 .into_dart()
6206 }
6207}
6208impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6209 for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>
6210{
6211}
6212impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>>
6213 for crate::bindings::LnUrlWithdrawRequestData
6214{
6215 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6216 self.into()
6217 }
6218}
6219impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawResult {
6221 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6222 match self {
6223 crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
6224 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6225 }
6226 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
6227 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6228 }
6229 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
6230 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6231 }
6232 _ => {
6233 unimplemented!("");
6234 }
6235 }
6236 }
6237}
6238impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6239 for crate::bindings::duplicates::LnUrlWithdrawResult
6240{
6241}
6242impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawResult>
6243 for crate::bindings::duplicates::LnUrlWithdrawResult
6244{
6245 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
6246 self
6247 }
6248}
6249impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6251 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6252 [self.invoice.into_into_dart().into_dart()].into_dart()
6253 }
6254}
6255impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6256 for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6257{
6258}
6259impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
6260 for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6261{
6262 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6263 self
6264 }
6265}
6266impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocaleOverrides> {
6268 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6269 [
6270 self.0.locale.into_into_dart().into_dart(),
6271 self.0.spacing.into_into_dart().into_dart(),
6272 self.0.symbol.into_into_dart().into_dart(),
6273 ]
6274 .into_dart()
6275 }
6276}
6277impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6278 for FrbWrapper<crate::bindings::LocaleOverrides>
6279{
6280}
6281impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocaleOverrides>>
6282 for crate::bindings::LocaleOverrides
6283{
6284 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocaleOverrides> {
6285 self.into()
6286 }
6287}
6288impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocalizedName> {
6290 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6291 [
6292 self.0.locale.into_into_dart().into_dart(),
6293 self.0.name.into_into_dart().into_dart(),
6294 ]
6295 .into_dart()
6296 }
6297}
6298impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6299 for FrbWrapper<crate::bindings::LocalizedName>
6300{
6301}
6302impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocalizedName>>
6303 for crate::bindings::LocalizedName
6304{
6305 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocalizedName> {
6306 self.into()
6307 }
6308}
6309impl flutter_rust_bridge::IntoDart for crate::model::LogEntry {
6311 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6312 [
6313 self.line.into_into_dart().into_dart(),
6314 self.level.into_into_dart().into_dart(),
6315 ]
6316 .into_dart()
6317 }
6318}
6319impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LogEntry {}
6320impl flutter_rust_bridge::IntoIntoDart<crate::model::LogEntry> for crate::model::LogEntry {
6321 fn into_into_dart(self) -> crate::model::LogEntry {
6322 self
6323 }
6324}
6325impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::MessageSuccessActionData> {
6327 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6328 [self.0.message.into_into_dart().into_dart()].into_dart()
6329 }
6330}
6331impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6332 for FrbWrapper<crate::bindings::MessageSuccessActionData>
6333{
6334}
6335impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::MessageSuccessActionData>>
6336 for crate::bindings::MessageSuccessActionData
6337{
6338 fn into_into_dart(self) -> FrbWrapper<crate::bindings::MessageSuccessActionData> {
6339 self.into()
6340 }
6341}
6342impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Network> {
6344 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6345 match self.0 {
6346 crate::bindings::Network::Bitcoin => 0.into_dart(),
6347 crate::bindings::Network::Testnet => 1.into_dart(),
6348 crate::bindings::Network::Signet => 2.into_dart(),
6349 crate::bindings::Network::Regtest => 3.into_dart(),
6350 _ => unreachable!(),
6351 }
6352 }
6353}
6354impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6355 for FrbWrapper<crate::bindings::Network>
6356{
6357}
6358impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Network>>
6359 for crate::bindings::Network
6360{
6361 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Network> {
6362 self.into()
6363 }
6364}
6365impl flutter_rust_bridge::IntoDart for crate::model::OnchainPaymentLimitsResponse {
6367 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6368 [
6369 self.send.into_into_dart().into_dart(),
6370 self.receive.into_into_dart().into_dart(),
6371 ]
6372 .into_dart()
6373 }
6374}
6375impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6376 for crate::model::OnchainPaymentLimitsResponse
6377{
6378}
6379impl flutter_rust_bridge::IntoIntoDart<crate::model::OnchainPaymentLimitsResponse>
6380 for crate::model::OnchainPaymentLimitsResponse
6381{
6382 fn into_into_dart(self) -> crate::model::OnchainPaymentLimitsResponse {
6383 self
6384 }
6385}
6386impl flutter_rust_bridge::IntoDart for crate::model::PayAmount {
6388 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6389 match self {
6390 crate::model::PayAmount::Bitcoin {
6391 receiver_amount_sat,
6392 } => [
6393 0.into_dart(),
6394 receiver_amount_sat.into_into_dart().into_dart(),
6395 ]
6396 .into_dart(),
6397 crate::model::PayAmount::Asset {
6398 asset_id,
6399 receiver_amount,
6400 estimate_asset_fees,
6401 } => [
6402 1.into_dart(),
6403 asset_id.into_into_dart().into_dart(),
6404 receiver_amount.into_into_dart().into_dart(),
6405 estimate_asset_fees.into_into_dart().into_dart(),
6406 ]
6407 .into_dart(),
6408 crate::model::PayAmount::Drain => [2.into_dart()].into_dart(),
6409 _ => {
6410 unimplemented!("");
6411 }
6412 }
6413 }
6414}
6415impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PayAmount {}
6416impl flutter_rust_bridge::IntoIntoDart<crate::model::PayAmount> for crate::model::PayAmount {
6417 fn into_into_dart(self) -> crate::model::PayAmount {
6418 self
6419 }
6420}
6421impl flutter_rust_bridge::IntoDart for crate::model::PayOnchainRequest {
6423 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6424 [
6425 self.address.into_into_dart().into_dart(),
6426 self.prepare_response.into_into_dart().into_dart(),
6427 ]
6428 .into_dart()
6429 }
6430}
6431impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6432 for crate::model::PayOnchainRequest
6433{
6434}
6435impl flutter_rust_bridge::IntoIntoDart<crate::model::PayOnchainRequest>
6436 for crate::model::PayOnchainRequest
6437{
6438 fn into_into_dart(self) -> crate::model::PayOnchainRequest {
6439 self
6440 }
6441}
6442impl flutter_rust_bridge::IntoDart for crate::model::Payment {
6444 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6445 [
6446 self.destination.into_into_dart().into_dart(),
6447 self.tx_id.into_into_dart().into_dart(),
6448 self.unblinding_data.into_into_dart().into_dart(),
6449 self.timestamp.into_into_dart().into_dart(),
6450 self.amount_sat.into_into_dart().into_dart(),
6451 self.fees_sat.into_into_dart().into_dart(),
6452 self.swapper_fees_sat.into_into_dart().into_dart(),
6453 self.payment_type.into_into_dart().into_dart(),
6454 self.status.into_into_dart().into_dart(),
6455 self.details.into_into_dart().into_dart(),
6456 ]
6457 .into_dart()
6458 }
6459}
6460impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Payment {}
6461impl flutter_rust_bridge::IntoIntoDart<crate::model::Payment> for crate::model::Payment {
6462 fn into_into_dart(self) -> crate::model::Payment {
6463 self
6464 }
6465}
6466impl flutter_rust_bridge::IntoDart for crate::model::PaymentDetails {
6468 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6469 match self {
6470 crate::model::PaymentDetails::Lightning {
6471 swap_id,
6472 description,
6473 liquid_expiration_blockheight,
6474 preimage,
6475 invoice,
6476 bolt12_offer,
6477 payment_hash,
6478 destination_pubkey,
6479 lnurl_info,
6480 bip353_address,
6481 claim_tx_id,
6482 refund_tx_id,
6483 refund_tx_amount_sat,
6484 } => [
6485 0.into_dart(),
6486 swap_id.into_into_dart().into_dart(),
6487 description.into_into_dart().into_dart(),
6488 liquid_expiration_blockheight.into_into_dart().into_dart(),
6489 preimage.into_into_dart().into_dart(),
6490 invoice.into_into_dart().into_dart(),
6491 bolt12_offer.into_into_dart().into_dart(),
6492 payment_hash.into_into_dart().into_dart(),
6493 destination_pubkey.into_into_dart().into_dart(),
6494 lnurl_info.into_into_dart().into_dart(),
6495 bip353_address.into_into_dart().into_dart(),
6496 claim_tx_id.into_into_dart().into_dart(),
6497 refund_tx_id.into_into_dart().into_dart(),
6498 refund_tx_amount_sat.into_into_dart().into_dart(),
6499 ]
6500 .into_dart(),
6501 crate::model::PaymentDetails::Liquid {
6502 destination,
6503 description,
6504 asset_id,
6505 asset_info,
6506 lnurl_info,
6507 bip353_address,
6508 } => [
6509 1.into_dart(),
6510 destination.into_into_dart().into_dart(),
6511 description.into_into_dart().into_dart(),
6512 asset_id.into_into_dart().into_dart(),
6513 asset_info.into_into_dart().into_dart(),
6514 lnurl_info.into_into_dart().into_dart(),
6515 bip353_address.into_into_dart().into_dart(),
6516 ]
6517 .into_dart(),
6518 crate::model::PaymentDetails::Bitcoin {
6519 swap_id,
6520 bitcoin_address,
6521 description,
6522 auto_accepted_fees,
6523 liquid_expiration_blockheight,
6524 bitcoin_expiration_blockheight,
6525 lockup_tx_id,
6526 claim_tx_id,
6527 refund_tx_id,
6528 refund_tx_amount_sat,
6529 } => [
6530 2.into_dart(),
6531 swap_id.into_into_dart().into_dart(),
6532 bitcoin_address.into_into_dart().into_dart(),
6533 description.into_into_dart().into_dart(),
6534 auto_accepted_fees.into_into_dart().into_dart(),
6535 liquid_expiration_blockheight.into_into_dart().into_dart(),
6536 bitcoin_expiration_blockheight.into_into_dart().into_dart(),
6537 lockup_tx_id.into_into_dart().into_dart(),
6538 claim_tx_id.into_into_dart().into_dart(),
6539 refund_tx_id.into_into_dart().into_dart(),
6540 refund_tx_amount_sat.into_into_dart().into_dart(),
6541 ]
6542 .into_dart(),
6543 _ => {
6544 unimplemented!("");
6545 }
6546 }
6547 }
6548}
6549impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentDetails {}
6550impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentDetails>
6551 for crate::model::PaymentDetails
6552{
6553 fn into_into_dart(self) -> crate::model::PaymentDetails {
6554 self
6555 }
6556}
6557impl flutter_rust_bridge::IntoDart for crate::error::PaymentError {
6559 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6560 match self {
6561 crate::error::PaymentError::AlreadyClaimed => [0.into_dart()].into_dart(),
6562 crate::error::PaymentError::AlreadyPaid => [1.into_dart()].into_dart(),
6563 crate::error::PaymentError::PaymentInProgress => [2.into_dart()].into_dart(),
6564 crate::error::PaymentError::AmountOutOfRange { min, max } => [
6565 3.into_dart(),
6566 min.into_into_dart().into_dart(),
6567 max.into_into_dart().into_dart(),
6568 ]
6569 .into_dart(),
6570 crate::error::PaymentError::AmountMissing { err } => {
6571 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6572 }
6573 crate::error::PaymentError::AssetError { err } => {
6574 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6575 }
6576 crate::error::PaymentError::InvalidNetwork { err } => {
6577 [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
6578 }
6579 crate::error::PaymentError::Generic { err } => {
6580 [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
6581 }
6582 crate::error::PaymentError::InvalidOrExpiredFees => [8.into_dart()].into_dart(),
6583 crate::error::PaymentError::InsufficientFunds => [9.into_dart()].into_dart(),
6584 crate::error::PaymentError::InvalidDescription { err } => {
6585 [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6586 }
6587 crate::error::PaymentError::InvalidInvoice { err } => {
6588 [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6589 }
6590 crate::error::PaymentError::InvalidPreimage => [12.into_dart()].into_dart(),
6591 crate::error::PaymentError::PairsNotFound => [13.into_dart()].into_dart(),
6592 crate::error::PaymentError::PaymentTimeout => [14.into_dart()].into_dart(),
6593 crate::error::PaymentError::PersistError => [15.into_dart()].into_dart(),
6594 crate::error::PaymentError::ReceiveError { err } => {
6595 [16.into_dart(), err.into_into_dart().into_dart()].into_dart()
6596 }
6597 crate::error::PaymentError::Refunded { err, refund_tx_id } => [
6598 17.into_dart(),
6599 err.into_into_dart().into_dart(),
6600 refund_tx_id.into_into_dart().into_dart(),
6601 ]
6602 .into_dart(),
6603 crate::error::PaymentError::SelfTransferNotSupported => [18.into_dart()].into_dart(),
6604 crate::error::PaymentError::SendError { err } => {
6605 [19.into_dart(), err.into_into_dart().into_dart()].into_dart()
6606 }
6607 crate::error::PaymentError::SignerError { err } => {
6608 [20.into_dart(), err.into_into_dart().into_dart()].into_dart()
6609 }
6610 _ => {
6611 unimplemented!("");
6612 }
6613 }
6614 }
6615}
6616impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::PaymentError {}
6617impl flutter_rust_bridge::IntoIntoDart<crate::error::PaymentError> for crate::error::PaymentError {
6618 fn into_into_dart(self) -> crate::error::PaymentError {
6619 self
6620 }
6621}
6622impl flutter_rust_bridge::IntoDart for crate::model::PaymentMethod {
6624 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6625 match self {
6626 Self::Lightning => 0.into_dart(),
6627 Self::Bolt11Invoice => 1.into_dart(),
6628 Self::Bolt12Offer => 2.into_dart(),
6629 Self::BitcoinAddress => 3.into_dart(),
6630 Self::LiquidAddress => 4.into_dart(),
6631 _ => unreachable!(),
6632 }
6633 }
6634}
6635impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentMethod {}
6636impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentMethod>
6637 for crate::model::PaymentMethod
6638{
6639 fn into_into_dart(self) -> crate::model::PaymentMethod {
6640 self
6641 }
6642}
6643impl flutter_rust_bridge::IntoDart for crate::model::PaymentState {
6645 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6646 match self {
6647 Self::Created => 0.into_dart(),
6648 Self::Pending => 1.into_dart(),
6649 Self::Complete => 2.into_dart(),
6650 Self::Failed => 3.into_dart(),
6651 Self::TimedOut => 4.into_dart(),
6652 Self::Refundable => 5.into_dart(),
6653 Self::RefundPending => 6.into_dart(),
6654 Self::WaitingFeeAcceptance => 7.into_dart(),
6655 _ => unreachable!(),
6656 }
6657 }
6658}
6659impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentState {}
6660impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentState> for crate::model::PaymentState {
6661 fn into_into_dart(self) -> crate::model::PaymentState {
6662 self
6663 }
6664}
6665impl flutter_rust_bridge::IntoDart for crate::model::PaymentType {
6667 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6668 match self {
6669 Self::Receive => 0.into_dart(),
6670 Self::Send => 1.into_dart(),
6671 _ => unreachable!(),
6672 }
6673 }
6674}
6675impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentType {}
6676impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentType> for crate::model::PaymentType {
6677 fn into_into_dart(self) -> crate::model::PaymentType {
6678 self
6679 }
6680}
6681impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinRequest {
6683 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6684 [
6685 self.provider.into_into_dart().into_dart(),
6686 self.amount_sat.into_into_dart().into_dart(),
6687 ]
6688 .into_dart()
6689 }
6690}
6691impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6692 for crate::model::PrepareBuyBitcoinRequest
6693{
6694}
6695impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinRequest>
6696 for crate::model::PrepareBuyBitcoinRequest
6697{
6698 fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinRequest {
6699 self
6700 }
6701}
6702impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinResponse {
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 self.fees_sat.into_into_dart().into_dart(),
6709 ]
6710 .into_dart()
6711 }
6712}
6713impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6714 for crate::model::PrepareBuyBitcoinResponse
6715{
6716}
6717impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinResponse>
6718 for crate::model::PrepareBuyBitcoinResponse
6719{
6720 fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinResponse {
6721 self
6722 }
6723}
6724impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayRequest {
6726 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6727 [
6728 self.data.into_into_dart().into_dart(),
6729 self.amount.into_into_dart().into_dart(),
6730 self.bip353_address.into_into_dart().into_dart(),
6731 self.comment.into_into_dart().into_dart(),
6732 self.validate_success_action_url
6733 .into_into_dart()
6734 .into_dart(),
6735 ]
6736 .into_dart()
6737 }
6738}
6739impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6740 for crate::model::PrepareLnUrlPayRequest
6741{
6742}
6743impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayRequest>
6744 for crate::model::PrepareLnUrlPayRequest
6745{
6746 fn into_into_dart(self) -> crate::model::PrepareLnUrlPayRequest {
6747 self
6748 }
6749}
6750impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayResponse {
6752 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6753 [
6754 self.destination.into_into_dart().into_dart(),
6755 self.fees_sat.into_into_dart().into_dart(),
6756 self.data.into_into_dart().into_dart(),
6757 self.amount.into_into_dart().into_dart(),
6758 self.comment.into_into_dart().into_dart(),
6759 self.success_action.into_into_dart().into_dart(),
6760 ]
6761 .into_dart()
6762 }
6763}
6764impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6765 for crate::model::PrepareLnUrlPayResponse
6766{
6767}
6768impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayResponse>
6769 for crate::model::PrepareLnUrlPayResponse
6770{
6771 fn into_into_dart(self) -> crate::model::PrepareLnUrlPayResponse {
6772 self
6773 }
6774}
6775impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainRequest {
6777 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6778 [
6779 self.amount.into_into_dart().into_dart(),
6780 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6781 ]
6782 .into_dart()
6783 }
6784}
6785impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6786 for crate::model::PreparePayOnchainRequest
6787{
6788}
6789impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainRequest>
6790 for crate::model::PreparePayOnchainRequest
6791{
6792 fn into_into_dart(self) -> crate::model::PreparePayOnchainRequest {
6793 self
6794 }
6795}
6796impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainResponse {
6798 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6799 [
6800 self.receiver_amount_sat.into_into_dart().into_dart(),
6801 self.claim_fees_sat.into_into_dart().into_dart(),
6802 self.total_fees_sat.into_into_dart().into_dart(),
6803 ]
6804 .into_dart()
6805 }
6806}
6807impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6808 for crate::model::PreparePayOnchainResponse
6809{
6810}
6811impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainResponse>
6812 for crate::model::PreparePayOnchainResponse
6813{
6814 fn into_into_dart(self) -> crate::model::PreparePayOnchainResponse {
6815 self
6816 }
6817}
6818impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveRequest {
6820 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6821 [
6822 self.payment_method.into_into_dart().into_dart(),
6823 self.amount.into_into_dart().into_dart(),
6824 ]
6825 .into_dart()
6826 }
6827}
6828impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6829 for crate::model::PrepareReceiveRequest
6830{
6831}
6832impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveRequest>
6833 for crate::model::PrepareReceiveRequest
6834{
6835 fn into_into_dart(self) -> crate::model::PrepareReceiveRequest {
6836 self
6837 }
6838}
6839impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveResponse {
6841 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6842 [
6843 self.payment_method.into_into_dart().into_dart(),
6844 self.fees_sat.into_into_dart().into_dart(),
6845 self.amount.into_into_dart().into_dart(),
6846 self.min_payer_amount_sat.into_into_dart().into_dart(),
6847 self.max_payer_amount_sat.into_into_dart().into_dart(),
6848 self.swapper_feerate.into_into_dart().into_dart(),
6849 ]
6850 .into_dart()
6851 }
6852}
6853impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6854 for crate::model::PrepareReceiveResponse
6855{
6856}
6857impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveResponse>
6858 for crate::model::PrepareReceiveResponse
6859{
6860 fn into_into_dart(self) -> crate::model::PrepareReceiveResponse {
6861 self
6862 }
6863}
6864impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundRequest {
6866 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6867 [
6868 self.swap_address.into_into_dart().into_dart(),
6869 self.refund_address.into_into_dart().into_dart(),
6870 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6871 ]
6872 .into_dart()
6873 }
6874}
6875impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6876 for crate::model::PrepareRefundRequest
6877{
6878}
6879impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundRequest>
6880 for crate::model::PrepareRefundRequest
6881{
6882 fn into_into_dart(self) -> crate::model::PrepareRefundRequest {
6883 self
6884 }
6885}
6886impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundResponse {
6888 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6889 [
6890 self.tx_vsize.into_into_dart().into_dart(),
6891 self.tx_fee_sat.into_into_dart().into_dart(),
6892 self.last_refund_tx_id.into_into_dart().into_dart(),
6893 ]
6894 .into_dart()
6895 }
6896}
6897impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6898 for crate::model::PrepareRefundResponse
6899{
6900}
6901impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundResponse>
6902 for crate::model::PrepareRefundResponse
6903{
6904 fn into_into_dart(self) -> crate::model::PrepareRefundResponse {
6905 self
6906 }
6907}
6908impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendRequest {
6910 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6911 [
6912 self.destination.into_into_dart().into_dart(),
6913 self.amount.into_into_dart().into_dart(),
6914 self.comment.into_into_dart().into_dart(),
6915 ]
6916 .into_dart()
6917 }
6918}
6919impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6920 for crate::model::PrepareSendRequest
6921{
6922}
6923impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendRequest>
6924 for crate::model::PrepareSendRequest
6925{
6926 fn into_into_dart(self) -> crate::model::PrepareSendRequest {
6927 self
6928 }
6929}
6930impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendResponse {
6932 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6933 [
6934 self.destination.into_into_dart().into_dart(),
6935 self.amount.into_into_dart().into_dart(),
6936 self.fees_sat.into_into_dart().into_dart(),
6937 self.estimated_asset_fees.into_into_dart().into_dart(),
6938 ]
6939 .into_dart()
6940 }
6941}
6942impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6943 for crate::model::PrepareSendResponse
6944{
6945}
6946impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendResponse>
6947 for crate::model::PrepareSendResponse
6948{
6949 fn into_into_dart(self) -> crate::model::PrepareSendResponse {
6950 self
6951 }
6952}
6953impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Rate> {
6955 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6956 [
6957 self.0.coin.into_into_dart().into_dart(),
6958 self.0.value.into_into_dart().into_dart(),
6959 ]
6960 .into_dart()
6961 }
6962}
6963impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6964 for FrbWrapper<crate::bindings::Rate>
6965{
6966}
6967impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Rate>>
6968 for crate::bindings::Rate
6969{
6970 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Rate> {
6971 self.into()
6972 }
6973}
6974impl flutter_rust_bridge::IntoDart for crate::model::ReceiveAmount {
6976 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6977 match self {
6978 crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
6979 [0.into_dart(), payer_amount_sat.into_into_dart().into_dart()].into_dart()
6980 }
6981 crate::model::ReceiveAmount::Asset {
6982 asset_id,
6983 payer_amount,
6984 } => [
6985 1.into_dart(),
6986 asset_id.into_into_dart().into_dart(),
6987 payer_amount.into_into_dart().into_dart(),
6988 ]
6989 .into_dart(),
6990 _ => {
6991 unimplemented!("");
6992 }
6993 }
6994 }
6995}
6996impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ReceiveAmount {}
6997impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceiveAmount>
6998 for crate::model::ReceiveAmount
6999{
7000 fn into_into_dart(self) -> crate::model::ReceiveAmount {
7001 self
7002 }
7003}
7004impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentRequest {
7006 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7007 [
7008 self.prepare_response.into_into_dart().into_dart(),
7009 self.description.into_into_dart().into_dart(),
7010 self.use_description_hash.into_into_dart().into_dart(),
7011 ]
7012 .into_dart()
7013 }
7014}
7015impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7016 for crate::model::ReceivePaymentRequest
7017{
7018}
7019impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentRequest>
7020 for crate::model::ReceivePaymentRequest
7021{
7022 fn into_into_dart(self) -> crate::model::ReceivePaymentRequest {
7023 self
7024 }
7025}
7026impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentResponse {
7028 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7029 [self.destination.into_into_dart().into_dart()].into_dart()
7030 }
7031}
7032impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7033 for crate::model::ReceivePaymentResponse
7034{
7035}
7036impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentResponse>
7037 for crate::model::ReceivePaymentResponse
7038{
7039 fn into_into_dart(self) -> crate::model::ReceivePaymentResponse {
7040 self
7041 }
7042}
7043impl flutter_rust_bridge::IntoDart for crate::model::RecommendedFees {
7045 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7046 [
7047 self.fastest_fee.into_into_dart().into_dart(),
7048 self.half_hour_fee.into_into_dart().into_dart(),
7049 self.hour_fee.into_into_dart().into_dart(),
7050 self.economy_fee.into_into_dart().into_dart(),
7051 self.minimum_fee.into_into_dart().into_dart(),
7052 ]
7053 .into_dart()
7054 }
7055}
7056impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RecommendedFees {}
7057impl flutter_rust_bridge::IntoIntoDart<crate::model::RecommendedFees>
7058 for crate::model::RecommendedFees
7059{
7060 fn into_into_dart(self) -> crate::model::RecommendedFees {
7061 self
7062 }
7063}
7064impl flutter_rust_bridge::IntoDart for crate::model::RefundRequest {
7066 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7067 [
7068 self.swap_address.into_into_dart().into_dart(),
7069 self.refund_address.into_into_dart().into_dart(),
7070 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
7071 ]
7072 .into_dart()
7073 }
7074}
7075impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundRequest {}
7076impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundRequest>
7077 for crate::model::RefundRequest
7078{
7079 fn into_into_dart(self) -> crate::model::RefundRequest {
7080 self
7081 }
7082}
7083impl flutter_rust_bridge::IntoDart for crate::model::RefundResponse {
7085 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7086 [self.refund_tx_id.into_into_dart().into_dart()].into_dart()
7087 }
7088}
7089impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundResponse {}
7090impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundResponse>
7091 for crate::model::RefundResponse
7092{
7093 fn into_into_dart(self) -> crate::model::RefundResponse {
7094 self
7095 }
7096}
7097impl flutter_rust_bridge::IntoDart for crate::model::RefundableSwap {
7099 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7100 [
7101 self.swap_address.into_into_dart().into_dart(),
7102 self.timestamp.into_into_dart().into_dart(),
7103 self.amount_sat.into_into_dart().into_dart(),
7104 self.last_refund_tx_id.into_into_dart().into_dart(),
7105 ]
7106 .into_dart()
7107 }
7108}
7109impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundableSwap {}
7110impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundableSwap>
7111 for crate::model::RefundableSwap
7112{
7113 fn into_into_dart(self) -> crate::model::RefundableSwap {
7114 self
7115 }
7116}
7117impl flutter_rust_bridge::IntoDart for crate::model::RestoreRequest {
7119 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7120 [self.backup_path.into_into_dart().into_dart()].into_dart()
7121 }
7122}
7123impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RestoreRequest {}
7124impl flutter_rust_bridge::IntoIntoDart<crate::model::RestoreRequest>
7125 for crate::model::RestoreRequest
7126{
7127 fn into_into_dart(self) -> crate::model::RestoreRequest {
7128 self
7129 }
7130}
7131impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHint> {
7133 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7134 [self.0.hops.into_into_dart().into_dart()].into_dart()
7135 }
7136}
7137impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7138 for FrbWrapper<crate::bindings::RouteHint>
7139{
7140}
7141impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHint>>
7142 for crate::bindings::RouteHint
7143{
7144 fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHint> {
7145 self.into()
7146 }
7147}
7148impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHintHop> {
7150 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7151 [
7152 self.0.src_node_id.into_into_dart().into_dart(),
7153 self.0.short_channel_id.into_into_dart().into_dart(),
7154 self.0.fees_base_msat.into_into_dart().into_dart(),
7155 self.0
7156 .fees_proportional_millionths
7157 .into_into_dart()
7158 .into_dart(),
7159 self.0.cltv_expiry_delta.into_into_dart().into_dart(),
7160 self.0.htlc_minimum_msat.into_into_dart().into_dart(),
7161 self.0.htlc_maximum_msat.into_into_dart().into_dart(),
7162 ]
7163 .into_dart()
7164 }
7165}
7166impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7167 for FrbWrapper<crate::bindings::RouteHintHop>
7168{
7169}
7170impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHintHop>>
7171 for crate::bindings::RouteHintHop
7172{
7173 fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHintHop> {
7174 self.into()
7175 }
7176}
7177impl flutter_rust_bridge::IntoDart for crate::error::SdkError {
7179 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7180 match self {
7181 crate::error::SdkError::AlreadyStarted => [0.into_dart()].into_dart(),
7182 crate::error::SdkError::Generic { err } => {
7183 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
7184 }
7185 crate::error::SdkError::NotStarted => [2.into_dart()].into_dart(),
7186 crate::error::SdkError::ServiceConnectivity { err } => {
7187 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
7188 }
7189 _ => {
7190 unimplemented!("");
7191 }
7192 }
7193 }
7194}
7195impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::SdkError {}
7196impl flutter_rust_bridge::IntoIntoDart<crate::error::SdkError> for crate::error::SdkError {
7197 fn into_into_dart(self) -> crate::error::SdkError {
7198 self
7199 }
7200}
7201impl flutter_rust_bridge::IntoDart for crate::model::SdkEvent {
7203 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7204 match self {
7205 crate::model::SdkEvent::PaymentFailed { details } => {
7206 [0.into_dart(), details.into_into_dart().into_dart()].into_dart()
7207 }
7208 crate::model::SdkEvent::PaymentPending { details } => {
7209 [1.into_dart(), details.into_into_dart().into_dart()].into_dart()
7210 }
7211 crate::model::SdkEvent::PaymentRefundable { details } => {
7212 [2.into_dart(), details.into_into_dart().into_dart()].into_dart()
7213 }
7214 crate::model::SdkEvent::PaymentRefunded { details } => {
7215 [3.into_dart(), details.into_into_dart().into_dart()].into_dart()
7216 }
7217 crate::model::SdkEvent::PaymentRefundPending { details } => {
7218 [4.into_dart(), details.into_into_dart().into_dart()].into_dart()
7219 }
7220 crate::model::SdkEvent::PaymentSucceeded { details } => {
7221 [5.into_dart(), details.into_into_dart().into_dart()].into_dart()
7222 }
7223 crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
7224 [6.into_dart(), details.into_into_dart().into_dart()].into_dart()
7225 }
7226 crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
7227 [7.into_dart(), details.into_into_dart().into_dart()].into_dart()
7228 }
7229 crate::model::SdkEvent::Synced => [8.into_dart()].into_dart(),
7230 crate::model::SdkEvent::DataSynced {
7231 did_pull_new_records,
7232 } => [
7233 9.into_dart(),
7234 did_pull_new_records.into_into_dart().into_dart(),
7235 ]
7236 .into_dart(),
7237 _ => {
7238 unimplemented!("");
7239 }
7240 }
7241 }
7242}
7243impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SdkEvent {}
7244impl flutter_rust_bridge::IntoIntoDart<crate::model::SdkEvent> for crate::model::SdkEvent {
7245 fn into_into_dart(self) -> crate::model::SdkEvent {
7246 self
7247 }
7248}
7249impl flutter_rust_bridge::IntoDart for crate::model::SendDestination {
7251 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7252 match self {
7253 crate::model::SendDestination::LiquidAddress {
7254 address_data,
7255 bip353_address,
7256 } => [
7257 0.into_dart(),
7258 address_data.into_into_dart().into_dart(),
7259 bip353_address.into_into_dart().into_dart(),
7260 ]
7261 .into_dart(),
7262 crate::model::SendDestination::Bolt11 {
7263 invoice,
7264 bip353_address,
7265 } => [
7266 1.into_dart(),
7267 invoice.into_into_dart().into_dart(),
7268 bip353_address.into_into_dart().into_dart(),
7269 ]
7270 .into_dart(),
7271 crate::model::SendDestination::Bolt12 {
7272 offer,
7273 receiver_amount_sat,
7274 bip353_address,
7275 payer_note,
7276 } => [
7277 2.into_dart(),
7278 offer.into_into_dart().into_dart(),
7279 receiver_amount_sat.into_into_dart().into_dart(),
7280 bip353_address.into_into_dart().into_dart(),
7281 payer_note.into_into_dart().into_dart(),
7282 ]
7283 .into_dart(),
7284 _ => {
7285 unimplemented!("");
7286 }
7287 }
7288 }
7289}
7290impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SendDestination {}
7291impl flutter_rust_bridge::IntoIntoDart<crate::model::SendDestination>
7292 for crate::model::SendDestination
7293{
7294 fn into_into_dart(self) -> crate::model::SendDestination {
7295 self
7296 }
7297}
7298impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentRequest {
7300 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7301 [
7302 self.prepare_response.into_into_dart().into_dart(),
7303 self.use_asset_fees.into_into_dart().into_dart(),
7304 ]
7305 .into_dart()
7306 }
7307}
7308impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7309 for crate::model::SendPaymentRequest
7310{
7311}
7312impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentRequest>
7313 for crate::model::SendPaymentRequest
7314{
7315 fn into_into_dart(self) -> crate::model::SendPaymentRequest {
7316 self
7317 }
7318}
7319impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentResponse {
7321 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7322 [self.payment.into_into_dart().into_dart()].into_dart()
7323 }
7324}
7325impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7326 for crate::model::SendPaymentResponse
7327{
7328}
7329impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentResponse>
7330 for crate::model::SendPaymentResponse
7331{
7332 fn into_into_dart(self) -> crate::model::SendPaymentResponse {
7333 self
7334 }
7335}
7336impl flutter_rust_bridge::IntoDart for crate::model::SignMessageRequest {
7338 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7339 [self.message.into_into_dart().into_dart()].into_dart()
7340 }
7341}
7342impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7343 for crate::model::SignMessageRequest
7344{
7345}
7346impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageRequest>
7347 for crate::model::SignMessageRequest
7348{
7349 fn into_into_dart(self) -> crate::model::SignMessageRequest {
7350 self
7351 }
7352}
7353impl flutter_rust_bridge::IntoDart for crate::model::SignMessageResponse {
7355 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7356 [self.signature.into_into_dart().into_dart()].into_dart()
7357 }
7358}
7359impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7360 for crate::model::SignMessageResponse
7361{
7362}
7363impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageResponse>
7364 for crate::model::SignMessageResponse
7365{
7366 fn into_into_dart(self) -> crate::model::SignMessageResponse {
7367 self
7368 }
7369}
7370impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessAction> {
7372 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7373 match self.0 {
7374 crate::bindings::SuccessAction::Aes { data } => {
7375 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
7376 }
7377 crate::bindings::SuccessAction::Message { data } => {
7378 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7379 }
7380 crate::bindings::SuccessAction::Url { data } => {
7381 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7382 }
7383 _ => {
7384 unimplemented!("");
7385 }
7386 }
7387 }
7388}
7389impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7390 for FrbWrapper<crate::bindings::SuccessAction>
7391{
7392}
7393impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessAction>>
7394 for crate::bindings::SuccessAction
7395{
7396 fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessAction> {
7397 self.into()
7398 }
7399}
7400impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessActionProcessed> {
7402 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7403 match self.0 {
7404 crate::bindings::SuccessActionProcessed::Aes { result } => {
7405 [0.into_dart(), result.into_into_dart().into_dart()].into_dart()
7406 }
7407 crate::bindings::SuccessActionProcessed::Message { data } => {
7408 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7409 }
7410 crate::bindings::SuccessActionProcessed::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::SuccessActionProcessed>
7421{
7422}
7423impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessActionProcessed>>
7424 for crate::bindings::SuccessActionProcessed
7425{
7426 fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessActionProcessed> {
7427 self.into()
7428 }
7429}
7430impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Symbol> {
7432 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7433 [
7434 self.0.grapheme.into_into_dart().into_dart(),
7435 self.0.template.into_into_dart().into_dart(),
7436 self.0.rtl.into_into_dart().into_dart(),
7437 self.0.position.into_into_dart().into_dart(),
7438 ]
7439 .into_dart()
7440 }
7441}
7442impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7443 for FrbWrapper<crate::bindings::Symbol>
7444{
7445}
7446impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Symbol>>
7447 for crate::bindings::Symbol
7448{
7449 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Symbol> {
7450 self.into()
7451 }
7452}
7453impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::UrlSuccessActionData> {
7455 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7456 [
7457 self.0.description.into_into_dart().into_dart(),
7458 self.0.url.into_into_dart().into_dart(),
7459 self.0.matches_callback_domain.into_into_dart().into_dart(),
7460 ]
7461 .into_dart()
7462 }
7463}
7464impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7465 for FrbWrapper<crate::bindings::UrlSuccessActionData>
7466{
7467}
7468impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::UrlSuccessActionData>>
7469 for crate::bindings::UrlSuccessActionData
7470{
7471 fn into_into_dart(self) -> FrbWrapper<crate::bindings::UrlSuccessActionData> {
7472 self.into()
7473 }
7474}
7475impl flutter_rust_bridge::IntoDart for crate::model::WalletInfo {
7477 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7478 [
7479 self.balance_sat.into_into_dart().into_dart(),
7480 self.pending_send_sat.into_into_dart().into_dart(),
7481 self.pending_receive_sat.into_into_dart().into_dart(),
7482 self.fingerprint.into_into_dart().into_dart(),
7483 self.pubkey.into_into_dart().into_dart(),
7484 self.asset_balances.into_into_dart().into_dart(),
7485 ]
7486 .into_dart()
7487 }
7488}
7489impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::WalletInfo {}
7490impl flutter_rust_bridge::IntoIntoDart<crate::model::WalletInfo> for crate::model::WalletInfo {
7491 fn into_into_dart(self) -> crate::model::WalletInfo {
7492 self
7493 }
7494}
7495
7496impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
7497 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7499 <String>::sse_encode(format!("{:?}", self), serializer);
7500 }
7501}
7502
7503impl SseEncode for BindingLiquidSdk {
7504 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7506 <RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer);
7507 }
7508}
7509
7510impl SseEncode
7511 for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
7512{
7513 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7515 let (ptr, size) = self.sse_encode_raw();
7516 <usize>::sse_encode(ptr, serializer);
7517 <i32>::sse_encode(size, serializer);
7518 }
7519}
7520
7521impl SseEncode
7522 for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
7523{
7524 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7526 unimplemented!("")
7527 }
7528}
7529
7530impl SseEncode
7531 for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
7532{
7533 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7535 unimplemented!("")
7536 }
7537}
7538
7539impl SseEncode for String {
7540 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7542 <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
7543 }
7544}
7545
7546impl SseEncode for crate::model::AcceptPaymentProposedFeesRequest {
7547 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7549 <crate::model::FetchPaymentProposedFeesResponse>::sse_encode(self.response, serializer);
7550 }
7551}
7552
7553impl SseEncode for crate::bindings::AesSuccessActionData {
7554 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7556 <String>::sse_encode(self.description, serializer);
7557 <String>::sse_encode(self.ciphertext, serializer);
7558 <String>::sse_encode(self.iv, serializer);
7559 }
7560}
7561
7562impl SseEncode for crate::bindings::AesSuccessActionDataDecrypted {
7563 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7565 <String>::sse_encode(self.description, serializer);
7566 <String>::sse_encode(self.plaintext, serializer);
7567 }
7568}
7569
7570impl SseEncode for crate::bindings::AesSuccessActionDataResult {
7571 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7573 match self {
7574 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
7575 <i32>::sse_encode(0, serializer);
7576 <crate::bindings::AesSuccessActionDataDecrypted>::sse_encode(data, serializer);
7577 }
7578 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
7579 <i32>::sse_encode(1, serializer);
7580 <String>::sse_encode(reason, serializer);
7581 }
7582 _ => {
7583 unimplemented!("");
7584 }
7585 }
7586 }
7587}
7588
7589impl SseEncode for crate::bindings::Amount {
7590 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7592 match self {
7593 crate::bindings::Amount::Bitcoin { amount_msat } => {
7594 <i32>::sse_encode(0, serializer);
7595 <u64>::sse_encode(amount_msat, serializer);
7596 }
7597 crate::bindings::Amount::Currency {
7598 iso4217_code,
7599 fractional_amount,
7600 } => {
7601 <i32>::sse_encode(1, serializer);
7602 <String>::sse_encode(iso4217_code, serializer);
7603 <u64>::sse_encode(fractional_amount, serializer);
7604 }
7605 _ => {
7606 unimplemented!("");
7607 }
7608 }
7609 }
7610}
7611
7612impl SseEncode for crate::model::AssetBalance {
7613 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7615 <String>::sse_encode(self.asset_id, serializer);
7616 <u64>::sse_encode(self.balance_sat, serializer);
7617 <Option<String>>::sse_encode(self.name, serializer);
7618 <Option<String>>::sse_encode(self.ticker, serializer);
7619 <Option<f64>>::sse_encode(self.balance, serializer);
7620 }
7621}
7622
7623impl SseEncode for crate::model::AssetInfo {
7624 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7626 <String>::sse_encode(self.name, serializer);
7627 <String>::sse_encode(self.ticker, serializer);
7628 <f64>::sse_encode(self.amount, serializer);
7629 <Option<f64>>::sse_encode(self.fees, serializer);
7630 }
7631}
7632
7633impl SseEncode for crate::model::AssetMetadata {
7634 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7636 <String>::sse_encode(self.asset_id, serializer);
7637 <String>::sse_encode(self.name, serializer);
7638 <String>::sse_encode(self.ticker, serializer);
7639 <u8>::sse_encode(self.precision, serializer);
7640 <Option<String>>::sse_encode(self.fiat_id, serializer);
7641 }
7642}
7643
7644impl SseEncode for crate::model::BackupRequest {
7645 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7647 <Option<String>>::sse_encode(self.backup_path, serializer);
7648 }
7649}
7650
7651impl SseEncode for crate::bindings::BindingEventListener {
7652 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7654 <StreamSink<crate::model::SdkEvent,flutter_rust_bridge::for_generated::DcoCodec>>::sse_encode(self.stream, serializer);
7655 }
7656}
7657
7658impl SseEncode for crate::bindings::BitcoinAddressData {
7659 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7661 <String>::sse_encode(self.address, serializer);
7662 <crate::bindings::Network>::sse_encode(self.network, serializer);
7663 <Option<u64>>::sse_encode(self.amount_sat, serializer);
7664 <Option<String>>::sse_encode(self.label, serializer);
7665 <Option<String>>::sse_encode(self.message, serializer);
7666 }
7667}
7668
7669impl SseEncode for crate::model::BlockchainExplorer {
7670 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7672 match self {
7673 crate::model::BlockchainExplorer::Electrum { url } => {
7674 <i32>::sse_encode(0, serializer);
7675 <String>::sse_encode(url, serializer);
7676 }
7677 crate::model::BlockchainExplorer::Esplora {
7678 url,
7679 use_waterfalls,
7680 } => {
7681 <i32>::sse_encode(1, serializer);
7682 <String>::sse_encode(url, serializer);
7683 <bool>::sse_encode(use_waterfalls, serializer);
7684 }
7685 _ => {
7686 unimplemented!("");
7687 }
7688 }
7689 }
7690}
7691
7692impl SseEncode for crate::model::BlockchainInfo {
7693 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7695 <u32>::sse_encode(self.liquid_tip, serializer);
7696 <u32>::sse_encode(self.bitcoin_tip, serializer);
7697 }
7698}
7699
7700impl SseEncode for bool {
7701 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7703 serializer.cursor.write_u8(self as _).unwrap();
7704 }
7705}
7706
7707impl SseEncode for crate::model::BuyBitcoinProvider {
7708 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7710 <i32>::sse_encode(
7711 match self {
7712 crate::model::BuyBitcoinProvider::Moonpay => 0,
7713 _ => {
7714 unimplemented!("");
7715 }
7716 },
7717 serializer,
7718 );
7719 }
7720}
7721
7722impl SseEncode for crate::model::BuyBitcoinRequest {
7723 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7725 <crate::model::PrepareBuyBitcoinResponse>::sse_encode(self.prepare_response, serializer);
7726 <Option<String>>::sse_encode(self.redirect_url, serializer);
7727 }
7728}
7729
7730impl SseEncode for crate::model::CheckMessageRequest {
7731 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7733 <String>::sse_encode(self.message, serializer);
7734 <String>::sse_encode(self.pubkey, serializer);
7735 <String>::sse_encode(self.signature, serializer);
7736 }
7737}
7738
7739impl SseEncode for crate::model::CheckMessageResponse {
7740 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7742 <bool>::sse_encode(self.is_valid, serializer);
7743 }
7744}
7745
7746impl SseEncode for crate::model::Config {
7747 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7749 <crate::model::BlockchainExplorer>::sse_encode(self.liquid_explorer, serializer);
7750 <crate::model::BlockchainExplorer>::sse_encode(self.bitcoin_explorer, serializer);
7751 <String>::sse_encode(self.working_dir, serializer);
7752 <crate::model::LiquidNetwork>::sse_encode(self.network, serializer);
7753 <u64>::sse_encode(self.payment_timeout_sec, serializer);
7754 <Option<String>>::sse_encode(self.sync_service_url, serializer);
7755 <Option<u64>>::sse_encode(self.zero_conf_max_amount_sat, serializer);
7756 <Option<String>>::sse_encode(self.breez_api_key, serializer);
7757 <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_encode(
7758 self.external_input_parsers,
7759 serializer,
7760 );
7761 <bool>::sse_encode(self.use_default_external_input_parsers, serializer);
7762 <Option<u32>>::sse_encode(self.onchain_fee_rate_leeway_sat_per_vbyte, serializer);
7763 <Option<Vec<crate::model::AssetMetadata>>>::sse_encode(self.asset_metadata, serializer);
7764 <Option<String>>::sse_encode(self.sideswap_api_key, serializer);
7765 }
7766}
7767
7768impl SseEncode for crate::model::ConnectRequest {
7769 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7771 <crate::model::Config>::sse_encode(self.config, serializer);
7772 <Option<String>>::sse_encode(self.mnemonic, serializer);
7773 <Option<String>>::sse_encode(self.passphrase, serializer);
7774 <Option<Vec<u8>>>::sse_encode(self.seed, serializer);
7775 }
7776}
7777
7778impl SseEncode for crate::model::CreateBolt12InvoiceRequest {
7779 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7781 <String>::sse_encode(self.offer, serializer);
7782 <String>::sse_encode(self.invoice_request, serializer);
7783 }
7784}
7785
7786impl SseEncode for crate::model::CreateBolt12InvoiceResponse {
7787 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7789 <String>::sse_encode(self.invoice, serializer);
7790 }
7791}
7792
7793impl SseEncode for crate::bindings::CurrencyInfo {
7794 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7796 <String>::sse_encode(self.name, serializer);
7797 <u32>::sse_encode(self.fraction_size, serializer);
7798 <Option<u32>>::sse_encode(self.spacing, serializer);
7799 <Option<crate::bindings::Symbol>>::sse_encode(self.symbol, serializer);
7800 <Option<crate::bindings::Symbol>>::sse_encode(self.uniq_symbol, serializer);
7801 <Vec<crate::bindings::LocalizedName>>::sse_encode(self.localized_name, serializer);
7802 <Vec<crate::bindings::LocaleOverrides>>::sse_encode(self.locale_overrides, serializer);
7803 }
7804}
7805
7806impl SseEncode for crate::bindings::ExternalInputParser {
7807 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7809 <String>::sse_encode(self.provider_id, serializer);
7810 <String>::sse_encode(self.input_regex, serializer);
7811 <String>::sse_encode(self.parser_url, serializer);
7812 }
7813}
7814
7815impl SseEncode for f64 {
7816 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7818 serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
7819 }
7820}
7821
7822impl SseEncode for crate::model::FetchPaymentProposedFeesRequest {
7823 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7825 <String>::sse_encode(self.swap_id, serializer);
7826 }
7827}
7828
7829impl SseEncode for crate::model::FetchPaymentProposedFeesResponse {
7830 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7832 <String>::sse_encode(self.swap_id, serializer);
7833 <u64>::sse_encode(self.fees_sat, serializer);
7834 <u64>::sse_encode(self.payer_amount_sat, serializer);
7835 <u64>::sse_encode(self.receiver_amount_sat, serializer);
7836 }
7837}
7838
7839impl SseEncode for crate::bindings::FiatCurrency {
7840 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7842 <String>::sse_encode(self.id, serializer);
7843 <crate::bindings::CurrencyInfo>::sse_encode(self.info, serializer);
7844 }
7845}
7846
7847impl SseEncode for crate::model::GetInfoResponse {
7848 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7850 <crate::model::WalletInfo>::sse_encode(self.wallet_info, serializer);
7851 <crate::model::BlockchainInfo>::sse_encode(self.blockchain_info, serializer);
7852 }
7853}
7854
7855impl SseEncode for crate::model::GetPaymentRequest {
7856 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7858 match self {
7859 crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
7860 <i32>::sse_encode(0, serializer);
7861 <String>::sse_encode(payment_hash, serializer);
7862 }
7863 crate::model::GetPaymentRequest::SwapId { swap_id } => {
7864 <i32>::sse_encode(1, serializer);
7865 <String>::sse_encode(swap_id, serializer);
7866 }
7867 _ => {
7868 unimplemented!("");
7869 }
7870 }
7871 }
7872}
7873
7874impl SseEncode for i32 {
7875 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7877 serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
7878 }
7879}
7880
7881impl SseEncode for i64 {
7882 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7884 serializer.cursor.write_i64::<NativeEndian>(self).unwrap();
7885 }
7886}
7887
7888impl SseEncode for crate::bindings::InputType {
7889 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7891 match self {
7892 crate::bindings::InputType::BitcoinAddress { address } => {
7893 <i32>::sse_encode(0, serializer);
7894 <crate::bindings::BitcoinAddressData>::sse_encode(address, serializer);
7895 }
7896 crate::bindings::InputType::LiquidAddress { address } => {
7897 <i32>::sse_encode(1, serializer);
7898 <crate::bindings::LiquidAddressData>::sse_encode(address, serializer);
7899 }
7900 crate::bindings::InputType::Bolt11 { invoice } => {
7901 <i32>::sse_encode(2, serializer);
7902 <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
7903 }
7904 crate::bindings::InputType::Bolt12Offer {
7905 offer,
7906 bip353_address,
7907 } => {
7908 <i32>::sse_encode(3, serializer);
7909 <crate::bindings::LNOffer>::sse_encode(offer, serializer);
7910 <Option<String>>::sse_encode(bip353_address, serializer);
7911 }
7912 crate::bindings::InputType::NodeId { node_id } => {
7913 <i32>::sse_encode(4, serializer);
7914 <String>::sse_encode(node_id, serializer);
7915 }
7916 crate::bindings::InputType::Url { url } => {
7917 <i32>::sse_encode(5, serializer);
7918 <String>::sse_encode(url, serializer);
7919 }
7920 crate::bindings::InputType::LnUrlPay {
7921 data,
7922 bip353_address,
7923 } => {
7924 <i32>::sse_encode(6, serializer);
7925 <crate::bindings::LnUrlPayRequestData>::sse_encode(data, serializer);
7926 <Option<String>>::sse_encode(bip353_address, serializer);
7927 }
7928 crate::bindings::InputType::LnUrlWithdraw { data } => {
7929 <i32>::sse_encode(7, serializer);
7930 <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(data, serializer);
7931 }
7932 crate::bindings::InputType::LnUrlAuth { data } => {
7933 <i32>::sse_encode(8, serializer);
7934 <crate::bindings::LnUrlAuthRequestData>::sse_encode(data, serializer);
7935 }
7936 crate::bindings::InputType::LnUrlError { data } => {
7937 <i32>::sse_encode(9, serializer);
7938 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
7939 }
7940 _ => {
7941 unimplemented!("");
7942 }
7943 }
7944 }
7945}
7946
7947impl SseEncode for crate::model::LightningPaymentLimitsResponse {
7948 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7950 <crate::model::Limits>::sse_encode(self.send, serializer);
7951 <crate::model::Limits>::sse_encode(self.receive, serializer);
7952 }
7953}
7954
7955impl SseEncode for crate::model::Limits {
7956 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7958 <u64>::sse_encode(self.min_sat, serializer);
7959 <u64>::sse_encode(self.max_sat, serializer);
7960 <u64>::sse_encode(self.max_zero_conf_sat, serializer);
7961 }
7962}
7963
7964impl SseEncode for crate::bindings::LiquidAddressData {
7965 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7967 <String>::sse_encode(self.address, serializer);
7968 <crate::bindings::Network>::sse_encode(self.network, serializer);
7969 <Option<String>>::sse_encode(self.asset_id, serializer);
7970 <Option<f64>>::sse_encode(self.amount, serializer);
7971 <Option<u64>>::sse_encode(self.amount_sat, serializer);
7972 <Option<String>>::sse_encode(self.label, serializer);
7973 <Option<String>>::sse_encode(self.message, serializer);
7974 }
7975}
7976
7977impl SseEncode for crate::model::LiquidNetwork {
7978 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7980 <i32>::sse_encode(
7981 match self {
7982 crate::model::LiquidNetwork::Mainnet => 0,
7983 crate::model::LiquidNetwork::Testnet => 1,
7984 crate::model::LiquidNetwork::Regtest => 2,
7985 _ => {
7986 unimplemented!("");
7987 }
7988 },
7989 serializer,
7990 );
7991 }
7992}
7993
7994impl SseEncode for Vec<String> {
7995 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7997 <i32>::sse_encode(self.len() as _, serializer);
7998 for item in self {
7999 <String>::sse_encode(item, serializer);
8000 }
8001 }
8002}
8003
8004impl SseEncode for Vec<crate::model::AssetBalance> {
8005 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8007 <i32>::sse_encode(self.len() as _, serializer);
8008 for item in self {
8009 <crate::model::AssetBalance>::sse_encode(item, serializer);
8010 }
8011 }
8012}
8013
8014impl SseEncode for Vec<crate::model::AssetMetadata> {
8015 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8017 <i32>::sse_encode(self.len() as _, serializer);
8018 for item in self {
8019 <crate::model::AssetMetadata>::sse_encode(item, serializer);
8020 }
8021 }
8022}
8023
8024impl SseEncode for Vec<crate::bindings::ExternalInputParser> {
8025 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8027 <i32>::sse_encode(self.len() as _, serializer);
8028 for item in self {
8029 <crate::bindings::ExternalInputParser>::sse_encode(item, serializer);
8030 }
8031 }
8032}
8033
8034impl SseEncode for Vec<crate::bindings::FiatCurrency> {
8035 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8037 <i32>::sse_encode(self.len() as _, serializer);
8038 for item in self {
8039 <crate::bindings::FiatCurrency>::sse_encode(item, serializer);
8040 }
8041 }
8042}
8043
8044impl SseEncode for Vec<crate::bindings::LnOfferBlindedPath> {
8045 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8047 <i32>::sse_encode(self.len() as _, serializer);
8048 for item in self {
8049 <crate::bindings::LnOfferBlindedPath>::sse_encode(item, serializer);
8050 }
8051 }
8052}
8053
8054impl SseEncode for Vec<crate::bindings::LocaleOverrides> {
8055 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8057 <i32>::sse_encode(self.len() as _, serializer);
8058 for item in self {
8059 <crate::bindings::LocaleOverrides>::sse_encode(item, serializer);
8060 }
8061 }
8062}
8063
8064impl SseEncode for Vec<crate::bindings::LocalizedName> {
8065 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8067 <i32>::sse_encode(self.len() as _, serializer);
8068 for item in self {
8069 <crate::bindings::LocalizedName>::sse_encode(item, serializer);
8070 }
8071 }
8072}
8073
8074impl SseEncode for Vec<crate::model::Payment> {
8075 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8077 <i32>::sse_encode(self.len() as _, serializer);
8078 for item in self {
8079 <crate::model::Payment>::sse_encode(item, serializer);
8080 }
8081 }
8082}
8083
8084impl SseEncode for crate::model::ListPaymentDetails {
8085 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8087 match self {
8088 crate::model::ListPaymentDetails::Liquid {
8089 asset_id,
8090 destination,
8091 } => {
8092 <i32>::sse_encode(0, serializer);
8093 <Option<String>>::sse_encode(asset_id, serializer);
8094 <Option<String>>::sse_encode(destination, serializer);
8095 }
8096 crate::model::ListPaymentDetails::Bitcoin { address } => {
8097 <i32>::sse_encode(1, serializer);
8098 <Option<String>>::sse_encode(address, serializer);
8099 }
8100 _ => {
8101 unimplemented!("");
8102 }
8103 }
8104 }
8105}
8106
8107impl SseEncode for Vec<crate::model::PaymentState> {
8108 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8110 <i32>::sse_encode(self.len() as _, serializer);
8111 for item in self {
8112 <crate::model::PaymentState>::sse_encode(item, serializer);
8113 }
8114 }
8115}
8116
8117impl SseEncode for Vec<crate::model::PaymentType> {
8118 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8120 <i32>::sse_encode(self.len() as _, serializer);
8121 for item in self {
8122 <crate::model::PaymentType>::sse_encode(item, serializer);
8123 }
8124 }
8125}
8126
8127impl SseEncode for crate::model::ListPaymentsRequest {
8128 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8130 <Option<Vec<crate::model::PaymentType>>>::sse_encode(self.filters, serializer);
8131 <Option<Vec<crate::model::PaymentState>>>::sse_encode(self.states, serializer);
8132 <Option<i64>>::sse_encode(self.from_timestamp, serializer);
8133 <Option<i64>>::sse_encode(self.to_timestamp, serializer);
8134 <Option<u32>>::sse_encode(self.offset, serializer);
8135 <Option<u32>>::sse_encode(self.limit, serializer);
8136 <Option<crate::model::ListPaymentDetails>>::sse_encode(self.details, serializer);
8137 <Option<bool>>::sse_encode(self.sort_ascending, serializer);
8138 }
8139}
8140
8141impl SseEncode for Vec<u8> {
8142 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8144 <i32>::sse_encode(self.len() as _, serializer);
8145 for item in self {
8146 <u8>::sse_encode(item, serializer);
8147 }
8148 }
8149}
8150
8151impl SseEncode for Vec<crate::bindings::Rate> {
8152 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8154 <i32>::sse_encode(self.len() as _, serializer);
8155 for item in self {
8156 <crate::bindings::Rate>::sse_encode(item, serializer);
8157 }
8158 }
8159}
8160
8161impl SseEncode for Vec<crate::model::RefundableSwap> {
8162 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8164 <i32>::sse_encode(self.len() as _, serializer);
8165 for item in self {
8166 <crate::model::RefundableSwap>::sse_encode(item, serializer);
8167 }
8168 }
8169}
8170
8171impl SseEncode for Vec<crate::bindings::RouteHint> {
8172 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8174 <i32>::sse_encode(self.len() as _, serializer);
8175 for item in self {
8176 <crate::bindings::RouteHint>::sse_encode(item, serializer);
8177 }
8178 }
8179}
8180
8181impl SseEncode for Vec<crate::bindings::RouteHintHop> {
8182 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8184 <i32>::sse_encode(self.len() as _, serializer);
8185 for item in self {
8186 <crate::bindings::RouteHintHop>::sse_encode(item, serializer);
8187 }
8188 }
8189}
8190
8191impl SseEncode for crate::bindings::LNInvoice {
8192 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8194 <String>::sse_encode(self.bolt11, serializer);
8195 <crate::bindings::Network>::sse_encode(self.network, serializer);
8196 <String>::sse_encode(self.payee_pubkey, serializer);
8197 <String>::sse_encode(self.payment_hash, serializer);
8198 <Option<String>>::sse_encode(self.description, serializer);
8199 <Option<String>>::sse_encode(self.description_hash, serializer);
8200 <Option<u64>>::sse_encode(self.amount_msat, serializer);
8201 <u64>::sse_encode(self.timestamp, serializer);
8202 <u64>::sse_encode(self.expiry, serializer);
8203 <Vec<crate::bindings::RouteHint>>::sse_encode(self.routing_hints, serializer);
8204 <Vec<u8>>::sse_encode(self.payment_secret, serializer);
8205 <u64>::sse_encode(self.min_final_cltv_expiry_delta, serializer);
8206 }
8207}
8208
8209impl SseEncode for crate::bindings::LNOffer {
8210 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8212 <String>::sse_encode(self.offer, serializer);
8213 <Vec<String>>::sse_encode(self.chains, serializer);
8214 <Option<crate::bindings::Amount>>::sse_encode(self.min_amount, serializer);
8215 <Option<String>>::sse_encode(self.description, serializer);
8216 <Option<u64>>::sse_encode(self.absolute_expiry, serializer);
8217 <Option<String>>::sse_encode(self.issuer, serializer);
8218 <Option<String>>::sse_encode(self.signing_pubkey, serializer);
8219 <Vec<crate::bindings::LnOfferBlindedPath>>::sse_encode(self.paths, serializer);
8220 }
8221}
8222
8223impl SseEncode for crate::bindings::LnOfferBlindedPath {
8224 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8226 <Vec<String>>::sse_encode(self.blinded_hops, serializer);
8227 }
8228}
8229
8230impl SseEncode for crate::bindings::duplicates::LnUrlAuthError {
8231 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8233 match self {
8234 crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
8235 <i32>::sse_encode(0, serializer);
8236 <String>::sse_encode(err, serializer);
8237 }
8238 crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
8239 <i32>::sse_encode(1, serializer);
8240 <String>::sse_encode(err, serializer);
8241 }
8242 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
8243 <i32>::sse_encode(2, serializer);
8244 <String>::sse_encode(err, serializer);
8245 }
8246 _ => {
8247 unimplemented!("");
8248 }
8249 }
8250 }
8251}
8252
8253impl SseEncode for crate::bindings::LnUrlAuthRequestData {
8254 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8256 <String>::sse_encode(self.k1, serializer);
8257 <Option<String>>::sse_encode(self.action, serializer);
8258 <String>::sse_encode(self.domain, serializer);
8259 <String>::sse_encode(self.url, serializer);
8260 }
8261}
8262
8263impl SseEncode for crate::bindings::duplicates::LnUrlCallbackStatus {
8264 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8266 match self {
8267 crate::bindings::duplicates::LnUrlCallbackStatus::Ok => {
8268 <i32>::sse_encode(0, serializer);
8269 }
8270 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
8271 <i32>::sse_encode(1, serializer);
8272 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8273 }
8274 _ => {
8275 unimplemented!("");
8276 }
8277 }
8278 }
8279}
8280
8281impl SseEncode for crate::bindings::LnUrlErrorData {
8282 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8284 <String>::sse_encode(self.reason, serializer);
8285 }
8286}
8287
8288impl SseEncode for crate::model::LnUrlInfo {
8289 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8291 <Option<String>>::sse_encode(self.ln_address, serializer);
8292 <Option<String>>::sse_encode(self.lnurl_pay_comment, serializer);
8293 <Option<String>>::sse_encode(self.lnurl_pay_domain, serializer);
8294 <Option<String>>::sse_encode(self.lnurl_pay_metadata, serializer);
8295 <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8296 self.lnurl_pay_success_action,
8297 serializer,
8298 );
8299 <Option<crate::bindings::SuccessAction>>::sse_encode(
8300 self.lnurl_pay_unprocessed_success_action,
8301 serializer,
8302 );
8303 <Option<String>>::sse_encode(self.lnurl_withdraw_endpoint, serializer);
8304 }
8305}
8306
8307impl SseEncode for crate::bindings::duplicates::LnUrlPayError {
8308 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8310 match self {
8311 crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => {
8312 <i32>::sse_encode(0, serializer);
8313 }
8314 crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
8315 <i32>::sse_encode(1, serializer);
8316 <String>::sse_encode(err, serializer);
8317 }
8318 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
8319 <i32>::sse_encode(2, serializer);
8320 <String>::sse_encode(err, serializer);
8321 }
8322 crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
8323 <i32>::sse_encode(3, serializer);
8324 <String>::sse_encode(err, serializer);
8325 }
8326 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
8327 <i32>::sse_encode(4, serializer);
8328 <String>::sse_encode(err, serializer);
8329 }
8330 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
8331 <i32>::sse_encode(5, serializer);
8332 <String>::sse_encode(err, serializer);
8333 }
8334 crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
8335 <i32>::sse_encode(6, serializer);
8336 <String>::sse_encode(err, serializer);
8337 }
8338 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
8339 <i32>::sse_encode(7, serializer);
8340 <String>::sse_encode(err, serializer);
8341 }
8342 crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
8343 <i32>::sse_encode(8, serializer);
8344 <String>::sse_encode(err, serializer);
8345 }
8346 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
8347 <i32>::sse_encode(9, serializer);
8348 <String>::sse_encode(err, serializer);
8349 }
8350 crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
8351 <i32>::sse_encode(10, serializer);
8352 <String>::sse_encode(err, serializer);
8353 }
8354 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
8355 <i32>::sse_encode(11, serializer);
8356 <String>::sse_encode(err, serializer);
8357 }
8358 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
8359 <i32>::sse_encode(12, serializer);
8360 <String>::sse_encode(err, serializer);
8361 }
8362 _ => {
8363 unimplemented!("");
8364 }
8365 }
8366 }
8367}
8368
8369impl SseEncode for crate::bindings::LnUrlPayErrorData {
8370 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8372 <String>::sse_encode(self.payment_hash, serializer);
8373 <String>::sse_encode(self.reason, serializer);
8374 }
8375}
8376
8377impl SseEncode for crate::model::LnUrlPayRequest {
8378 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8380 <crate::model::PrepareLnUrlPayResponse>::sse_encode(self.prepare_response, serializer);
8381 }
8382}
8383
8384impl SseEncode for crate::bindings::LnUrlPayRequestData {
8385 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8387 <String>::sse_encode(self.callback, serializer);
8388 <u64>::sse_encode(self.min_sendable, serializer);
8389 <u64>::sse_encode(self.max_sendable, serializer);
8390 <String>::sse_encode(self.metadata_str, serializer);
8391 <u16>::sse_encode(self.comment_allowed, serializer);
8392 <String>::sse_encode(self.domain, serializer);
8393 <bool>::sse_encode(self.allows_nostr, serializer);
8394 <Option<String>>::sse_encode(self.nostr_pubkey, serializer);
8395 <Option<String>>::sse_encode(self.ln_address, serializer);
8396 }
8397}
8398
8399impl SseEncode for crate::model::LnUrlPayResult {
8400 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8402 match self {
8403 crate::model::LnUrlPayResult::EndpointSuccess { data } => {
8404 <i32>::sse_encode(0, serializer);
8405 <crate::model::LnUrlPaySuccessData>::sse_encode(data, serializer);
8406 }
8407 crate::model::LnUrlPayResult::EndpointError { data } => {
8408 <i32>::sse_encode(1, serializer);
8409 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8410 }
8411 crate::model::LnUrlPayResult::PayError { data } => {
8412 <i32>::sse_encode(2, serializer);
8413 <crate::bindings::LnUrlPayErrorData>::sse_encode(data, serializer);
8414 }
8415 _ => {
8416 unimplemented!("");
8417 }
8418 }
8419 }
8420}
8421
8422impl SseEncode for crate::model::LnUrlPaySuccessData {
8423 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8425 <crate::model::Payment>::sse_encode(self.payment, serializer);
8426 <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8427 self.success_action,
8428 serializer,
8429 );
8430 }
8431}
8432
8433impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawError {
8434 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8436 match self {
8437 crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
8438 <i32>::sse_encode(0, serializer);
8439 <String>::sse_encode(err, serializer);
8440 }
8441 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
8442 <i32>::sse_encode(1, serializer);
8443 <String>::sse_encode(err, serializer);
8444 }
8445 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
8446 <i32>::sse_encode(2, serializer);
8447 <String>::sse_encode(err, serializer);
8448 }
8449 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
8450 <i32>::sse_encode(3, serializer);
8451 <String>::sse_encode(err, serializer);
8452 }
8453 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
8454 <i32>::sse_encode(4, serializer);
8455 <String>::sse_encode(err, serializer);
8456 }
8457 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
8458 <i32>::sse_encode(5, serializer);
8459 <String>::sse_encode(err, serializer);
8460 }
8461 _ => {
8462 unimplemented!("");
8463 }
8464 }
8465 }
8466}
8467
8468impl SseEncode for crate::bindings::LnUrlWithdrawRequest {
8469 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8471 <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(self.data, serializer);
8472 <u64>::sse_encode(self.amount_msat, serializer);
8473 <Option<String>>::sse_encode(self.description, serializer);
8474 }
8475}
8476
8477impl SseEncode for crate::bindings::LnUrlWithdrawRequestData {
8478 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8480 <String>::sse_encode(self.callback, serializer);
8481 <String>::sse_encode(self.k1, serializer);
8482 <String>::sse_encode(self.default_description, serializer);
8483 <u64>::sse_encode(self.min_withdrawable, serializer);
8484 <u64>::sse_encode(self.max_withdrawable, serializer);
8485 }
8486}
8487
8488impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawResult {
8489 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8491 match self {
8492 crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
8493 <i32>::sse_encode(0, serializer);
8494 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8495 data, serializer,
8496 );
8497 }
8498 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
8499 <i32>::sse_encode(1, serializer);
8500 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8501 data, serializer,
8502 );
8503 }
8504 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
8505 <i32>::sse_encode(2, serializer);
8506 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8507 }
8508 _ => {
8509 unimplemented!("");
8510 }
8511 }
8512 }
8513}
8514
8515impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
8516 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8518 <crate::bindings::LNInvoice>::sse_encode(self.invoice, serializer);
8519 }
8520}
8521
8522impl SseEncode for crate::bindings::LocaleOverrides {
8523 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8525 <String>::sse_encode(self.locale, serializer);
8526 <Option<u32>>::sse_encode(self.spacing, serializer);
8527 <crate::bindings::Symbol>::sse_encode(self.symbol, serializer);
8528 }
8529}
8530
8531impl SseEncode for crate::bindings::LocalizedName {
8532 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8534 <String>::sse_encode(self.locale, serializer);
8535 <String>::sse_encode(self.name, serializer);
8536 }
8537}
8538
8539impl SseEncode for crate::model::LogEntry {
8540 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8542 <String>::sse_encode(self.line, serializer);
8543 <String>::sse_encode(self.level, serializer);
8544 }
8545}
8546
8547impl SseEncode for crate::bindings::MessageSuccessActionData {
8548 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8550 <String>::sse_encode(self.message, serializer);
8551 }
8552}
8553
8554impl SseEncode for crate::bindings::Network {
8555 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8557 <i32>::sse_encode(
8558 match self {
8559 crate::bindings::Network::Bitcoin => 0,
8560 crate::bindings::Network::Testnet => 1,
8561 crate::bindings::Network::Signet => 2,
8562 crate::bindings::Network::Regtest => 3,
8563 _ => {
8564 unimplemented!("");
8565 }
8566 },
8567 serializer,
8568 );
8569 }
8570}
8571
8572impl SseEncode for crate::model::OnchainPaymentLimitsResponse {
8573 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8575 <crate::model::Limits>::sse_encode(self.send, serializer);
8576 <crate::model::Limits>::sse_encode(self.receive, serializer);
8577 }
8578}
8579
8580impl SseEncode for Option<String> {
8581 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8583 <bool>::sse_encode(self.is_some(), serializer);
8584 if let Some(value) = self {
8585 <String>::sse_encode(value, serializer);
8586 }
8587 }
8588}
8589
8590impl SseEncode for Option<crate::bindings::Amount> {
8591 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8593 <bool>::sse_encode(self.is_some(), serializer);
8594 if let Some(value) = self {
8595 <crate::bindings::Amount>::sse_encode(value, serializer);
8596 }
8597 }
8598}
8599
8600impl SseEncode for Option<crate::model::AssetInfo> {
8601 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8603 <bool>::sse_encode(self.is_some(), serializer);
8604 if let Some(value) = self {
8605 <crate::model::AssetInfo>::sse_encode(value, serializer);
8606 }
8607 }
8608}
8609
8610impl SseEncode for Option<bool> {
8611 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8613 <bool>::sse_encode(self.is_some(), serializer);
8614 if let Some(value) = self {
8615 <bool>::sse_encode(value, serializer);
8616 }
8617 }
8618}
8619
8620impl SseEncode for Option<f64> {
8621 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8623 <bool>::sse_encode(self.is_some(), serializer);
8624 if let Some(value) = self {
8625 <f64>::sse_encode(value, serializer);
8626 }
8627 }
8628}
8629
8630impl SseEncode for Option<i64> {
8631 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8633 <bool>::sse_encode(self.is_some(), serializer);
8634 if let Some(value) = self {
8635 <i64>::sse_encode(value, serializer);
8636 }
8637 }
8638}
8639
8640impl SseEncode for Option<crate::model::ListPaymentDetails> {
8641 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8643 <bool>::sse_encode(self.is_some(), serializer);
8644 if let Some(value) = self {
8645 <crate::model::ListPaymentDetails>::sse_encode(value, serializer);
8646 }
8647 }
8648}
8649
8650impl SseEncode for Option<crate::model::LnUrlInfo> {
8651 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8653 <bool>::sse_encode(self.is_some(), serializer);
8654 if let Some(value) = self {
8655 <crate::model::LnUrlInfo>::sse_encode(value, serializer);
8656 }
8657 }
8658}
8659
8660impl SseEncode for Option<crate::model::PayAmount> {
8661 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8663 <bool>::sse_encode(self.is_some(), serializer);
8664 if let Some(value) = self {
8665 <crate::model::PayAmount>::sse_encode(value, serializer);
8666 }
8667 }
8668}
8669
8670impl SseEncode for Option<crate::model::Payment> {
8671 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8673 <bool>::sse_encode(self.is_some(), serializer);
8674 if let Some(value) = self {
8675 <crate::model::Payment>::sse_encode(value, serializer);
8676 }
8677 }
8678}
8679
8680impl SseEncode for Option<crate::model::ReceiveAmount> {
8681 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8683 <bool>::sse_encode(self.is_some(), serializer);
8684 if let Some(value) = self {
8685 <crate::model::ReceiveAmount>::sse_encode(value, serializer);
8686 }
8687 }
8688}
8689
8690impl SseEncode for Option<crate::bindings::SuccessAction> {
8691 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8693 <bool>::sse_encode(self.is_some(), serializer);
8694 if let Some(value) = self {
8695 <crate::bindings::SuccessAction>::sse_encode(value, serializer);
8696 }
8697 }
8698}
8699
8700impl SseEncode for Option<crate::bindings::SuccessActionProcessed> {
8701 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8703 <bool>::sse_encode(self.is_some(), serializer);
8704 if let Some(value) = self {
8705 <crate::bindings::SuccessActionProcessed>::sse_encode(value, serializer);
8706 }
8707 }
8708}
8709
8710impl SseEncode for Option<crate::bindings::Symbol> {
8711 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8713 <bool>::sse_encode(self.is_some(), serializer);
8714 if let Some(value) = self {
8715 <crate::bindings::Symbol>::sse_encode(value, serializer);
8716 }
8717 }
8718}
8719
8720impl SseEncode for Option<u32> {
8721 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8723 <bool>::sse_encode(self.is_some(), serializer);
8724 if let Some(value) = self {
8725 <u32>::sse_encode(value, serializer);
8726 }
8727 }
8728}
8729
8730impl SseEncode for Option<u64> {
8731 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8733 <bool>::sse_encode(self.is_some(), serializer);
8734 if let Some(value) = self {
8735 <u64>::sse_encode(value, serializer);
8736 }
8737 }
8738}
8739
8740impl SseEncode for Option<Vec<crate::model::AssetMetadata>> {
8741 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8743 <bool>::sse_encode(self.is_some(), serializer);
8744 if let Some(value) = self {
8745 <Vec<crate::model::AssetMetadata>>::sse_encode(value, serializer);
8746 }
8747 }
8748}
8749
8750impl SseEncode for Option<Vec<crate::bindings::ExternalInputParser>> {
8751 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8753 <bool>::sse_encode(self.is_some(), serializer);
8754 if let Some(value) = self {
8755 <Vec<crate::bindings::ExternalInputParser>>::sse_encode(value, serializer);
8756 }
8757 }
8758}
8759
8760impl SseEncode for Option<Vec<crate::model::PaymentState>> {
8761 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8763 <bool>::sse_encode(self.is_some(), serializer);
8764 if let Some(value) = self {
8765 <Vec<crate::model::PaymentState>>::sse_encode(value, serializer);
8766 }
8767 }
8768}
8769
8770impl SseEncode for Option<Vec<crate::model::PaymentType>> {
8771 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8773 <bool>::sse_encode(self.is_some(), serializer);
8774 if let Some(value) = self {
8775 <Vec<crate::model::PaymentType>>::sse_encode(value, serializer);
8776 }
8777 }
8778}
8779
8780impl SseEncode for Option<Vec<u8>> {
8781 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8783 <bool>::sse_encode(self.is_some(), serializer);
8784 if let Some(value) = self {
8785 <Vec<u8>>::sse_encode(value, serializer);
8786 }
8787 }
8788}
8789
8790impl SseEncode for crate::model::PayAmount {
8791 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8793 match self {
8794 crate::model::PayAmount::Bitcoin {
8795 receiver_amount_sat,
8796 } => {
8797 <i32>::sse_encode(0, serializer);
8798 <u64>::sse_encode(receiver_amount_sat, serializer);
8799 }
8800 crate::model::PayAmount::Asset {
8801 asset_id,
8802 receiver_amount,
8803 estimate_asset_fees,
8804 } => {
8805 <i32>::sse_encode(1, serializer);
8806 <String>::sse_encode(asset_id, serializer);
8807 <f64>::sse_encode(receiver_amount, serializer);
8808 <Option<bool>>::sse_encode(estimate_asset_fees, serializer);
8809 }
8810 crate::model::PayAmount::Drain => {
8811 <i32>::sse_encode(2, serializer);
8812 }
8813 _ => {
8814 unimplemented!("");
8815 }
8816 }
8817 }
8818}
8819
8820impl SseEncode for crate::model::PayOnchainRequest {
8821 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8823 <String>::sse_encode(self.address, serializer);
8824 <crate::model::PreparePayOnchainResponse>::sse_encode(self.prepare_response, serializer);
8825 }
8826}
8827
8828impl SseEncode for crate::model::Payment {
8829 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8831 <Option<String>>::sse_encode(self.destination, serializer);
8832 <Option<String>>::sse_encode(self.tx_id, serializer);
8833 <Option<String>>::sse_encode(self.unblinding_data, serializer);
8834 <u32>::sse_encode(self.timestamp, serializer);
8835 <u64>::sse_encode(self.amount_sat, serializer);
8836 <u64>::sse_encode(self.fees_sat, serializer);
8837 <Option<u64>>::sse_encode(self.swapper_fees_sat, serializer);
8838 <crate::model::PaymentType>::sse_encode(self.payment_type, serializer);
8839 <crate::model::PaymentState>::sse_encode(self.status, serializer);
8840 <crate::model::PaymentDetails>::sse_encode(self.details, serializer);
8841 }
8842}
8843
8844impl SseEncode for crate::model::PaymentDetails {
8845 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8847 match self {
8848 crate::model::PaymentDetails::Lightning {
8849 swap_id,
8850 description,
8851 liquid_expiration_blockheight,
8852 preimage,
8853 invoice,
8854 bolt12_offer,
8855 payment_hash,
8856 destination_pubkey,
8857 lnurl_info,
8858 bip353_address,
8859 claim_tx_id,
8860 refund_tx_id,
8861 refund_tx_amount_sat,
8862 } => {
8863 <i32>::sse_encode(0, serializer);
8864 <String>::sse_encode(swap_id, serializer);
8865 <String>::sse_encode(description, serializer);
8866 <u32>::sse_encode(liquid_expiration_blockheight, serializer);
8867 <Option<String>>::sse_encode(preimage, serializer);
8868 <Option<String>>::sse_encode(invoice, serializer);
8869 <Option<String>>::sse_encode(bolt12_offer, serializer);
8870 <Option<String>>::sse_encode(payment_hash, serializer);
8871 <Option<String>>::sse_encode(destination_pubkey, serializer);
8872 <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8873 <Option<String>>::sse_encode(bip353_address, serializer);
8874 <Option<String>>::sse_encode(claim_tx_id, serializer);
8875 <Option<String>>::sse_encode(refund_tx_id, serializer);
8876 <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8877 }
8878 crate::model::PaymentDetails::Liquid {
8879 destination,
8880 description,
8881 asset_id,
8882 asset_info,
8883 lnurl_info,
8884 bip353_address,
8885 } => {
8886 <i32>::sse_encode(1, serializer);
8887 <String>::sse_encode(destination, serializer);
8888 <String>::sse_encode(description, serializer);
8889 <String>::sse_encode(asset_id, serializer);
8890 <Option<crate::model::AssetInfo>>::sse_encode(asset_info, serializer);
8891 <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8892 <Option<String>>::sse_encode(bip353_address, serializer);
8893 }
8894 crate::model::PaymentDetails::Bitcoin {
8895 swap_id,
8896 bitcoin_address,
8897 description,
8898 auto_accepted_fees,
8899 liquid_expiration_blockheight,
8900 bitcoin_expiration_blockheight,
8901 lockup_tx_id,
8902 claim_tx_id,
8903 refund_tx_id,
8904 refund_tx_amount_sat,
8905 } => {
8906 <i32>::sse_encode(2, serializer);
8907 <String>::sse_encode(swap_id, serializer);
8908 <String>::sse_encode(bitcoin_address, serializer);
8909 <String>::sse_encode(description, serializer);
8910 <bool>::sse_encode(auto_accepted_fees, serializer);
8911 <Option<u32>>::sse_encode(liquid_expiration_blockheight, serializer);
8912 <Option<u32>>::sse_encode(bitcoin_expiration_blockheight, serializer);
8913 <Option<String>>::sse_encode(lockup_tx_id, serializer);
8914 <Option<String>>::sse_encode(claim_tx_id, serializer);
8915 <Option<String>>::sse_encode(refund_tx_id, serializer);
8916 <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8917 }
8918 _ => {
8919 unimplemented!("");
8920 }
8921 }
8922 }
8923}
8924
8925impl SseEncode for crate::error::PaymentError {
8926 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8928 match self {
8929 crate::error::PaymentError::AlreadyClaimed => {
8930 <i32>::sse_encode(0, serializer);
8931 }
8932 crate::error::PaymentError::AlreadyPaid => {
8933 <i32>::sse_encode(1, serializer);
8934 }
8935 crate::error::PaymentError::PaymentInProgress => {
8936 <i32>::sse_encode(2, serializer);
8937 }
8938 crate::error::PaymentError::AmountOutOfRange { min, max } => {
8939 <i32>::sse_encode(3, serializer);
8940 <u64>::sse_encode(min, serializer);
8941 <u64>::sse_encode(max, serializer);
8942 }
8943 crate::error::PaymentError::AmountMissing { err } => {
8944 <i32>::sse_encode(4, serializer);
8945 <String>::sse_encode(err, serializer);
8946 }
8947 crate::error::PaymentError::AssetError { err } => {
8948 <i32>::sse_encode(5, serializer);
8949 <String>::sse_encode(err, serializer);
8950 }
8951 crate::error::PaymentError::InvalidNetwork { err } => {
8952 <i32>::sse_encode(6, serializer);
8953 <String>::sse_encode(err, serializer);
8954 }
8955 crate::error::PaymentError::Generic { err } => {
8956 <i32>::sse_encode(7, serializer);
8957 <String>::sse_encode(err, serializer);
8958 }
8959 crate::error::PaymentError::InvalidOrExpiredFees => {
8960 <i32>::sse_encode(8, serializer);
8961 }
8962 crate::error::PaymentError::InsufficientFunds => {
8963 <i32>::sse_encode(9, serializer);
8964 }
8965 crate::error::PaymentError::InvalidDescription { err } => {
8966 <i32>::sse_encode(10, serializer);
8967 <String>::sse_encode(err, serializer);
8968 }
8969 crate::error::PaymentError::InvalidInvoice { err } => {
8970 <i32>::sse_encode(11, serializer);
8971 <String>::sse_encode(err, serializer);
8972 }
8973 crate::error::PaymentError::InvalidPreimage => {
8974 <i32>::sse_encode(12, serializer);
8975 }
8976 crate::error::PaymentError::PairsNotFound => {
8977 <i32>::sse_encode(13, serializer);
8978 }
8979 crate::error::PaymentError::PaymentTimeout => {
8980 <i32>::sse_encode(14, serializer);
8981 }
8982 crate::error::PaymentError::PersistError => {
8983 <i32>::sse_encode(15, serializer);
8984 }
8985 crate::error::PaymentError::ReceiveError { err } => {
8986 <i32>::sse_encode(16, serializer);
8987 <String>::sse_encode(err, serializer);
8988 }
8989 crate::error::PaymentError::Refunded { err, refund_tx_id } => {
8990 <i32>::sse_encode(17, serializer);
8991 <String>::sse_encode(err, serializer);
8992 <String>::sse_encode(refund_tx_id, serializer);
8993 }
8994 crate::error::PaymentError::SelfTransferNotSupported => {
8995 <i32>::sse_encode(18, serializer);
8996 }
8997 crate::error::PaymentError::SendError { err } => {
8998 <i32>::sse_encode(19, serializer);
8999 <String>::sse_encode(err, serializer);
9000 }
9001 crate::error::PaymentError::SignerError { err } => {
9002 <i32>::sse_encode(20, serializer);
9003 <String>::sse_encode(err, serializer);
9004 }
9005 _ => {
9006 unimplemented!("");
9007 }
9008 }
9009 }
9010}
9011
9012impl SseEncode for crate::model::PaymentMethod {
9013 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9015 <i32>::sse_encode(
9016 match self {
9017 crate::model::PaymentMethod::Lightning => 0,
9018 crate::model::PaymentMethod::Bolt11Invoice => 1,
9019 crate::model::PaymentMethod::Bolt12Offer => 2,
9020 crate::model::PaymentMethod::BitcoinAddress => 3,
9021 crate::model::PaymentMethod::LiquidAddress => 4,
9022 _ => {
9023 unimplemented!("");
9024 }
9025 },
9026 serializer,
9027 );
9028 }
9029}
9030
9031impl SseEncode for crate::model::PaymentState {
9032 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9034 <i32>::sse_encode(
9035 match self {
9036 crate::model::PaymentState::Created => 0,
9037 crate::model::PaymentState::Pending => 1,
9038 crate::model::PaymentState::Complete => 2,
9039 crate::model::PaymentState::Failed => 3,
9040 crate::model::PaymentState::TimedOut => 4,
9041 crate::model::PaymentState::Refundable => 5,
9042 crate::model::PaymentState::RefundPending => 6,
9043 crate::model::PaymentState::WaitingFeeAcceptance => 7,
9044 _ => {
9045 unimplemented!("");
9046 }
9047 },
9048 serializer,
9049 );
9050 }
9051}
9052
9053impl SseEncode for crate::model::PaymentType {
9054 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9056 <i32>::sse_encode(
9057 match self {
9058 crate::model::PaymentType::Receive => 0,
9059 crate::model::PaymentType::Send => 1,
9060 _ => {
9061 unimplemented!("");
9062 }
9063 },
9064 serializer,
9065 );
9066 }
9067}
9068
9069impl SseEncode for crate::model::PrepareBuyBitcoinRequest {
9070 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9072 <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9073 <u64>::sse_encode(self.amount_sat, serializer);
9074 }
9075}
9076
9077impl SseEncode for crate::model::PrepareBuyBitcoinResponse {
9078 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9080 <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9081 <u64>::sse_encode(self.amount_sat, serializer);
9082 <u64>::sse_encode(self.fees_sat, serializer);
9083 }
9084}
9085
9086impl SseEncode for crate::model::PrepareLnUrlPayRequest {
9087 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9089 <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9090 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9091 <Option<String>>::sse_encode(self.bip353_address, serializer);
9092 <Option<String>>::sse_encode(self.comment, serializer);
9093 <Option<bool>>::sse_encode(self.validate_success_action_url, serializer);
9094 }
9095}
9096
9097impl SseEncode for crate::model::PrepareLnUrlPayResponse {
9098 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9100 <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9101 <u64>::sse_encode(self.fees_sat, serializer);
9102 <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9103 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9104 <Option<String>>::sse_encode(self.comment, serializer);
9105 <Option<crate::bindings::SuccessAction>>::sse_encode(self.success_action, serializer);
9106 }
9107}
9108
9109impl SseEncode for crate::model::PreparePayOnchainRequest {
9110 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9112 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9113 <Option<u32>>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9114 }
9115}
9116
9117impl SseEncode for crate::model::PreparePayOnchainResponse {
9118 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9120 <u64>::sse_encode(self.receiver_amount_sat, serializer);
9121 <u64>::sse_encode(self.claim_fees_sat, serializer);
9122 <u64>::sse_encode(self.total_fees_sat, serializer);
9123 }
9124}
9125
9126impl SseEncode for crate::model::PrepareReceiveRequest {
9127 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9129 <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9130 <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9131 }
9132}
9133
9134impl SseEncode for crate::model::PrepareReceiveResponse {
9135 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9137 <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9138 <u64>::sse_encode(self.fees_sat, serializer);
9139 <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9140 <Option<u64>>::sse_encode(self.min_payer_amount_sat, serializer);
9141 <Option<u64>>::sse_encode(self.max_payer_amount_sat, serializer);
9142 <Option<f64>>::sse_encode(self.swapper_feerate, serializer);
9143 }
9144}
9145
9146impl SseEncode for crate::model::PrepareRefundRequest {
9147 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9149 <String>::sse_encode(self.swap_address, serializer);
9150 <String>::sse_encode(self.refund_address, serializer);
9151 <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9152 }
9153}
9154
9155impl SseEncode for crate::model::PrepareRefundResponse {
9156 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9158 <u32>::sse_encode(self.tx_vsize, serializer);
9159 <u64>::sse_encode(self.tx_fee_sat, serializer);
9160 <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9161 }
9162}
9163
9164impl SseEncode for crate::model::PrepareSendRequest {
9165 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9167 <String>::sse_encode(self.destination, serializer);
9168 <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9169 <Option<String>>::sse_encode(self.comment, serializer);
9170 }
9171}
9172
9173impl SseEncode for crate::model::PrepareSendResponse {
9174 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9176 <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9177 <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9178 <Option<u64>>::sse_encode(self.fees_sat, serializer);
9179 <Option<f64>>::sse_encode(self.estimated_asset_fees, serializer);
9180 }
9181}
9182
9183impl SseEncode for crate::bindings::Rate {
9184 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9186 <String>::sse_encode(self.coin, serializer);
9187 <f64>::sse_encode(self.value, serializer);
9188 }
9189}
9190
9191impl SseEncode for crate::model::ReceiveAmount {
9192 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9194 match self {
9195 crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
9196 <i32>::sse_encode(0, serializer);
9197 <u64>::sse_encode(payer_amount_sat, serializer);
9198 }
9199 crate::model::ReceiveAmount::Asset {
9200 asset_id,
9201 payer_amount,
9202 } => {
9203 <i32>::sse_encode(1, serializer);
9204 <String>::sse_encode(asset_id, serializer);
9205 <Option<f64>>::sse_encode(payer_amount, serializer);
9206 }
9207 _ => {
9208 unimplemented!("");
9209 }
9210 }
9211 }
9212}
9213
9214impl SseEncode for crate::model::ReceivePaymentRequest {
9215 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9217 <crate::model::PrepareReceiveResponse>::sse_encode(self.prepare_response, serializer);
9218 <Option<String>>::sse_encode(self.description, serializer);
9219 <Option<bool>>::sse_encode(self.use_description_hash, serializer);
9220 }
9221}
9222
9223impl SseEncode for crate::model::ReceivePaymentResponse {
9224 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9226 <String>::sse_encode(self.destination, serializer);
9227 }
9228}
9229
9230impl SseEncode for crate::model::RecommendedFees {
9231 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9233 <u64>::sse_encode(self.fastest_fee, serializer);
9234 <u64>::sse_encode(self.half_hour_fee, serializer);
9235 <u64>::sse_encode(self.hour_fee, serializer);
9236 <u64>::sse_encode(self.economy_fee, serializer);
9237 <u64>::sse_encode(self.minimum_fee, serializer);
9238 }
9239}
9240
9241impl SseEncode for crate::model::RefundRequest {
9242 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9244 <String>::sse_encode(self.swap_address, serializer);
9245 <String>::sse_encode(self.refund_address, serializer);
9246 <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9247 }
9248}
9249
9250impl SseEncode for crate::model::RefundResponse {
9251 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9253 <String>::sse_encode(self.refund_tx_id, serializer);
9254 }
9255}
9256
9257impl SseEncode for crate::model::RefundableSwap {
9258 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9260 <String>::sse_encode(self.swap_address, serializer);
9261 <u32>::sse_encode(self.timestamp, serializer);
9262 <u64>::sse_encode(self.amount_sat, serializer);
9263 <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9264 }
9265}
9266
9267impl SseEncode for crate::model::RestoreRequest {
9268 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9270 <Option<String>>::sse_encode(self.backup_path, serializer);
9271 }
9272}
9273
9274impl SseEncode for crate::bindings::RouteHint {
9275 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9277 <Vec<crate::bindings::RouteHintHop>>::sse_encode(self.hops, serializer);
9278 }
9279}
9280
9281impl SseEncode for crate::bindings::RouteHintHop {
9282 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9284 <String>::sse_encode(self.src_node_id, serializer);
9285 <String>::sse_encode(self.short_channel_id, serializer);
9286 <u32>::sse_encode(self.fees_base_msat, serializer);
9287 <u32>::sse_encode(self.fees_proportional_millionths, serializer);
9288 <u64>::sse_encode(self.cltv_expiry_delta, serializer);
9289 <Option<u64>>::sse_encode(self.htlc_minimum_msat, serializer);
9290 <Option<u64>>::sse_encode(self.htlc_maximum_msat, serializer);
9291 }
9292}
9293
9294impl SseEncode for crate::error::SdkError {
9295 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9297 match self {
9298 crate::error::SdkError::AlreadyStarted => {
9299 <i32>::sse_encode(0, serializer);
9300 }
9301 crate::error::SdkError::Generic { err } => {
9302 <i32>::sse_encode(1, serializer);
9303 <String>::sse_encode(err, serializer);
9304 }
9305 crate::error::SdkError::NotStarted => {
9306 <i32>::sse_encode(2, serializer);
9307 }
9308 crate::error::SdkError::ServiceConnectivity { err } => {
9309 <i32>::sse_encode(3, serializer);
9310 <String>::sse_encode(err, serializer);
9311 }
9312 _ => {
9313 unimplemented!("");
9314 }
9315 }
9316 }
9317}
9318
9319impl SseEncode for crate::model::SdkEvent {
9320 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9322 match self {
9323 crate::model::SdkEvent::PaymentFailed { details } => {
9324 <i32>::sse_encode(0, serializer);
9325 <crate::model::Payment>::sse_encode(details, serializer);
9326 }
9327 crate::model::SdkEvent::PaymentPending { details } => {
9328 <i32>::sse_encode(1, serializer);
9329 <crate::model::Payment>::sse_encode(details, serializer);
9330 }
9331 crate::model::SdkEvent::PaymentRefundable { details } => {
9332 <i32>::sse_encode(2, serializer);
9333 <crate::model::Payment>::sse_encode(details, serializer);
9334 }
9335 crate::model::SdkEvent::PaymentRefunded { details } => {
9336 <i32>::sse_encode(3, serializer);
9337 <crate::model::Payment>::sse_encode(details, serializer);
9338 }
9339 crate::model::SdkEvent::PaymentRefundPending { details } => {
9340 <i32>::sse_encode(4, serializer);
9341 <crate::model::Payment>::sse_encode(details, serializer);
9342 }
9343 crate::model::SdkEvent::PaymentSucceeded { details } => {
9344 <i32>::sse_encode(5, serializer);
9345 <crate::model::Payment>::sse_encode(details, serializer);
9346 }
9347 crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
9348 <i32>::sse_encode(6, serializer);
9349 <crate::model::Payment>::sse_encode(details, serializer);
9350 }
9351 crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
9352 <i32>::sse_encode(7, serializer);
9353 <crate::model::Payment>::sse_encode(details, serializer);
9354 }
9355 crate::model::SdkEvent::Synced => {
9356 <i32>::sse_encode(8, serializer);
9357 }
9358 crate::model::SdkEvent::DataSynced {
9359 did_pull_new_records,
9360 } => {
9361 <i32>::sse_encode(9, serializer);
9362 <bool>::sse_encode(did_pull_new_records, serializer);
9363 }
9364 _ => {
9365 unimplemented!("");
9366 }
9367 }
9368 }
9369}
9370
9371impl SseEncode for crate::model::SendDestination {
9372 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9374 match self {
9375 crate::model::SendDestination::LiquidAddress {
9376 address_data,
9377 bip353_address,
9378 } => {
9379 <i32>::sse_encode(0, serializer);
9380 <crate::bindings::LiquidAddressData>::sse_encode(address_data, serializer);
9381 <Option<String>>::sse_encode(bip353_address, serializer);
9382 }
9383 crate::model::SendDestination::Bolt11 {
9384 invoice,
9385 bip353_address,
9386 } => {
9387 <i32>::sse_encode(1, serializer);
9388 <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
9389 <Option<String>>::sse_encode(bip353_address, serializer);
9390 }
9391 crate::model::SendDestination::Bolt12 {
9392 offer,
9393 receiver_amount_sat,
9394 bip353_address,
9395 payer_note,
9396 } => {
9397 <i32>::sse_encode(2, serializer);
9398 <crate::bindings::LNOffer>::sse_encode(offer, serializer);
9399 <u64>::sse_encode(receiver_amount_sat, serializer);
9400 <Option<String>>::sse_encode(bip353_address, serializer);
9401 <Option<String>>::sse_encode(payer_note, serializer);
9402 }
9403 _ => {
9404 unimplemented!("");
9405 }
9406 }
9407 }
9408}
9409
9410impl SseEncode for crate::model::SendPaymentRequest {
9411 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9413 <crate::model::PrepareSendResponse>::sse_encode(self.prepare_response, serializer);
9414 <Option<bool>>::sse_encode(self.use_asset_fees, serializer);
9415 }
9416}
9417
9418impl SseEncode for crate::model::SendPaymentResponse {
9419 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9421 <crate::model::Payment>::sse_encode(self.payment, serializer);
9422 }
9423}
9424
9425impl SseEncode for crate::model::SignMessageRequest {
9426 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9428 <String>::sse_encode(self.message, serializer);
9429 }
9430}
9431
9432impl SseEncode for crate::model::SignMessageResponse {
9433 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9435 <String>::sse_encode(self.signature, serializer);
9436 }
9437}
9438
9439impl SseEncode for crate::bindings::SuccessAction {
9440 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9442 match self {
9443 crate::bindings::SuccessAction::Aes { data } => {
9444 <i32>::sse_encode(0, serializer);
9445 <crate::bindings::AesSuccessActionData>::sse_encode(data, serializer);
9446 }
9447 crate::bindings::SuccessAction::Message { data } => {
9448 <i32>::sse_encode(1, serializer);
9449 <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9450 }
9451 crate::bindings::SuccessAction::Url { data } => {
9452 <i32>::sse_encode(2, serializer);
9453 <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9454 }
9455 _ => {
9456 unimplemented!("");
9457 }
9458 }
9459 }
9460}
9461
9462impl SseEncode for crate::bindings::SuccessActionProcessed {
9463 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9465 match self {
9466 crate::bindings::SuccessActionProcessed::Aes { result } => {
9467 <i32>::sse_encode(0, serializer);
9468 <crate::bindings::AesSuccessActionDataResult>::sse_encode(result, serializer);
9469 }
9470 crate::bindings::SuccessActionProcessed::Message { data } => {
9471 <i32>::sse_encode(1, serializer);
9472 <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9473 }
9474 crate::bindings::SuccessActionProcessed::Url { data } => {
9475 <i32>::sse_encode(2, serializer);
9476 <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9477 }
9478 _ => {
9479 unimplemented!("");
9480 }
9481 }
9482 }
9483}
9484
9485impl SseEncode for crate::bindings::Symbol {
9486 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9488 <Option<String>>::sse_encode(self.grapheme, serializer);
9489 <Option<String>>::sse_encode(self.template, serializer);
9490 <Option<bool>>::sse_encode(self.rtl, serializer);
9491 <Option<u32>>::sse_encode(self.position, serializer);
9492 }
9493}
9494
9495impl SseEncode for u16 {
9496 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9498 serializer.cursor.write_u16::<NativeEndian>(self).unwrap();
9499 }
9500}
9501
9502impl SseEncode for u32 {
9503 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9505 serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
9506 }
9507}
9508
9509impl SseEncode for u64 {
9510 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9512 serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
9513 }
9514}
9515
9516impl SseEncode for u8 {
9517 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9519 serializer.cursor.write_u8(self).unwrap();
9520 }
9521}
9522
9523impl SseEncode for () {
9524 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
9526}
9527
9528impl SseEncode for crate::bindings::UrlSuccessActionData {
9529 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9531 <String>::sse_encode(self.description, serializer);
9532 <String>::sse_encode(self.url, serializer);
9533 <bool>::sse_encode(self.matches_callback_domain, serializer);
9534 }
9535}
9536
9537impl SseEncode for usize {
9538 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9540 serializer
9541 .cursor
9542 .write_u64::<NativeEndian>(self as _)
9543 .unwrap();
9544 }
9545}
9546
9547impl SseEncode for crate::model::WalletInfo {
9548 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9550 <u64>::sse_encode(self.balance_sat, serializer);
9551 <u64>::sse_encode(self.pending_send_sat, serializer);
9552 <u64>::sse_encode(self.pending_receive_sat, serializer);
9553 <String>::sse_encode(self.fingerprint, serializer);
9554 <String>::sse_encode(self.pubkey, serializer);
9555 <Vec<crate::model::AssetBalance>>::sse_encode(self.asset_balances, serializer);
9556 }
9557}
9558
9559#[cfg(not(target_family = "wasm"))]
9560mod io {
9561 use super::*;
9567 use crate::bindings::*;
9568 use crate::model::EventListener;
9569 use flutter_rust_bridge::for_generated::byteorder::{
9570 NativeEndian, ReadBytesExt, WriteBytesExt,
9571 };
9572 use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
9573 use flutter_rust_bridge::{Handler, IntoIntoDart};
9574
9575 flutter_rust_bridge::frb_generated_boilerplate_io!();
9578
9579 impl CstDecode<flutter_rust_bridge::for_generated::anyhow::Error>
9582 for *mut wire_cst_list_prim_u_8_strict
9583 {
9584 fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error {
9586 unimplemented!()
9587 }
9588 }
9589 impl CstDecode<BindingLiquidSdk> for usize {
9590 fn cst_decode(self) -> BindingLiquidSdk {
9592 flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::<
9593 RustOpaqueNom<
9594 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9595 >,
9596 >::cst_decode(
9597 self
9598 ))
9599 }
9600 }
9601 impl
9602 CstDecode<
9603 RustOpaqueNom<
9604 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9605 >,
9606 > for usize
9607 {
9608 fn cst_decode(
9610 self,
9611 ) -> RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
9612 {
9613 unsafe { decode_rust_opaque_nom(self as _) }
9614 }
9615 }
9616 impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>
9617 for *mut wire_cst_list_prim_u_8_strict
9618 {
9619 fn cst_decode(
9621 self,
9622 ) -> StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
9623 {
9624 let raw: String = self.cst_decode();
9625 StreamSink::deserialize(raw)
9626 }
9627 }
9628 impl CstDecode<StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>>
9629 for *mut wire_cst_list_prim_u_8_strict
9630 {
9631 fn cst_decode(
9633 self,
9634 ) -> StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
9635 {
9636 let raw: String = self.cst_decode();
9637 StreamSink::deserialize(raw)
9638 }
9639 }
9640 impl CstDecode<String> for *mut wire_cst_list_prim_u_8_strict {
9641 fn cst_decode(self) -> String {
9643 let vec: Vec<u8> = self.cst_decode();
9644 String::from_utf8(vec).unwrap()
9645 }
9646 }
9647 impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9648 for wire_cst_accept_payment_proposed_fees_request
9649 {
9650 fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9652 crate::model::AcceptPaymentProposedFeesRequest {
9653 response: self.response.cst_decode(),
9654 }
9655 }
9656 }
9657 impl CstDecode<crate::bindings::AesSuccessActionData> for wire_cst_aes_success_action_data {
9658 fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9660 crate::bindings::AesSuccessActionData {
9661 description: self.description.cst_decode(),
9662 ciphertext: self.ciphertext.cst_decode(),
9663 iv: self.iv.cst_decode(),
9664 }
9665 }
9666 }
9667 impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9668 for wire_cst_aes_success_action_data_decrypted
9669 {
9670 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9672 crate::bindings::AesSuccessActionDataDecrypted {
9673 description: self.description.cst_decode(),
9674 plaintext: self.plaintext.cst_decode(),
9675 }
9676 }
9677 }
9678 impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9679 for wire_cst_aes_success_action_data_result
9680 {
9681 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9683 match self.tag {
9684 0 => {
9685 let ans = unsafe { self.kind.Decrypted };
9686 crate::bindings::AesSuccessActionDataResult::Decrypted {
9687 data: ans.data.cst_decode(),
9688 }
9689 }
9690 1 => {
9691 let ans = unsafe { self.kind.ErrorStatus };
9692 crate::bindings::AesSuccessActionDataResult::ErrorStatus {
9693 reason: ans.reason.cst_decode(),
9694 }
9695 }
9696 _ => unreachable!(),
9697 }
9698 }
9699 }
9700 impl CstDecode<crate::bindings::Amount> for wire_cst_amount {
9701 fn cst_decode(self) -> crate::bindings::Amount {
9703 match self.tag {
9704 0 => {
9705 let ans = unsafe { self.kind.Bitcoin };
9706 crate::bindings::Amount::Bitcoin {
9707 amount_msat: ans.amount_msat.cst_decode(),
9708 }
9709 }
9710 1 => {
9711 let ans = unsafe { self.kind.Currency };
9712 crate::bindings::Amount::Currency {
9713 iso4217_code: ans.iso4217_code.cst_decode(),
9714 fractional_amount: ans.fractional_amount.cst_decode(),
9715 }
9716 }
9717 _ => unreachable!(),
9718 }
9719 }
9720 }
9721 impl CstDecode<crate::model::AssetBalance> for wire_cst_asset_balance {
9722 fn cst_decode(self) -> crate::model::AssetBalance {
9724 crate::model::AssetBalance {
9725 asset_id: self.asset_id.cst_decode(),
9726 balance_sat: self.balance_sat.cst_decode(),
9727 name: self.name.cst_decode(),
9728 ticker: self.ticker.cst_decode(),
9729 balance: self.balance.cst_decode(),
9730 }
9731 }
9732 }
9733 impl CstDecode<crate::model::AssetInfo> for wire_cst_asset_info {
9734 fn cst_decode(self) -> crate::model::AssetInfo {
9736 crate::model::AssetInfo {
9737 name: self.name.cst_decode(),
9738 ticker: self.ticker.cst_decode(),
9739 amount: self.amount.cst_decode(),
9740 fees: self.fees.cst_decode(),
9741 }
9742 }
9743 }
9744 impl CstDecode<crate::model::AssetMetadata> for wire_cst_asset_metadata {
9745 fn cst_decode(self) -> crate::model::AssetMetadata {
9747 crate::model::AssetMetadata {
9748 asset_id: self.asset_id.cst_decode(),
9749 name: self.name.cst_decode(),
9750 ticker: self.ticker.cst_decode(),
9751 precision: self.precision.cst_decode(),
9752 fiat_id: self.fiat_id.cst_decode(),
9753 }
9754 }
9755 }
9756 impl CstDecode<crate::model::BackupRequest> for wire_cst_backup_request {
9757 fn cst_decode(self) -> crate::model::BackupRequest {
9759 crate::model::BackupRequest {
9760 backup_path: self.backup_path.cst_decode(),
9761 }
9762 }
9763 }
9764 impl CstDecode<crate::bindings::BindingEventListener> for wire_cst_binding_event_listener {
9765 fn cst_decode(self) -> crate::bindings::BindingEventListener {
9767 crate::bindings::BindingEventListener {
9768 stream: self.stream.cst_decode(),
9769 }
9770 }
9771 }
9772 impl CstDecode<crate::bindings::BitcoinAddressData> for wire_cst_bitcoin_address_data {
9773 fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9775 crate::bindings::BitcoinAddressData {
9776 address: self.address.cst_decode(),
9777 network: self.network.cst_decode(),
9778 amount_sat: self.amount_sat.cst_decode(),
9779 label: self.label.cst_decode(),
9780 message: self.message.cst_decode(),
9781 }
9782 }
9783 }
9784 impl CstDecode<crate::model::BlockchainExplorer> for wire_cst_blockchain_explorer {
9785 fn cst_decode(self) -> crate::model::BlockchainExplorer {
9787 match self.tag {
9788 0 => {
9789 let ans = unsafe { self.kind.Electrum };
9790 crate::model::BlockchainExplorer::Electrum {
9791 url: ans.url.cst_decode(),
9792 }
9793 }
9794 1 => {
9795 let ans = unsafe { self.kind.Esplora };
9796 crate::model::BlockchainExplorer::Esplora {
9797 url: ans.url.cst_decode(),
9798 use_waterfalls: ans.use_waterfalls.cst_decode(),
9799 }
9800 }
9801 _ => unreachable!(),
9802 }
9803 }
9804 }
9805 impl CstDecode<crate::model::BlockchainInfo> for wire_cst_blockchain_info {
9806 fn cst_decode(self) -> crate::model::BlockchainInfo {
9808 crate::model::BlockchainInfo {
9809 liquid_tip: self.liquid_tip.cst_decode(),
9810 bitcoin_tip: self.bitcoin_tip.cst_decode(),
9811 }
9812 }
9813 }
9814 impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9815 for *mut wire_cst_accept_payment_proposed_fees_request
9816 {
9817 fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9819 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9820 CstDecode::<crate::model::AcceptPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9821 }
9822 }
9823 impl CstDecode<crate::bindings::AesSuccessActionData> for *mut wire_cst_aes_success_action_data {
9824 fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9826 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9827 CstDecode::<crate::bindings::AesSuccessActionData>::cst_decode(*wrap).into()
9828 }
9829 }
9830 impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9831 for *mut wire_cst_aes_success_action_data_decrypted
9832 {
9833 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9835 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9836 CstDecode::<crate::bindings::AesSuccessActionDataDecrypted>::cst_decode(*wrap).into()
9837 }
9838 }
9839 impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9840 for *mut wire_cst_aes_success_action_data_result
9841 {
9842 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9844 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9845 CstDecode::<crate::bindings::AesSuccessActionDataResult>::cst_decode(*wrap).into()
9846 }
9847 }
9848 impl CstDecode<crate::bindings::Amount> for *mut wire_cst_amount {
9849 fn cst_decode(self) -> crate::bindings::Amount {
9851 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9852 CstDecode::<crate::bindings::Amount>::cst_decode(*wrap).into()
9853 }
9854 }
9855 impl CstDecode<crate::model::AssetInfo> for *mut wire_cst_asset_info {
9856 fn cst_decode(self) -> crate::model::AssetInfo {
9858 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9859 CstDecode::<crate::model::AssetInfo>::cst_decode(*wrap).into()
9860 }
9861 }
9862 impl CstDecode<crate::model::BackupRequest> for *mut wire_cst_backup_request {
9863 fn cst_decode(self) -> crate::model::BackupRequest {
9865 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9866 CstDecode::<crate::model::BackupRequest>::cst_decode(*wrap).into()
9867 }
9868 }
9869 impl CstDecode<crate::bindings::BindingEventListener> for *mut wire_cst_binding_event_listener {
9870 fn cst_decode(self) -> crate::bindings::BindingEventListener {
9872 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9873 CstDecode::<crate::bindings::BindingEventListener>::cst_decode(*wrap).into()
9874 }
9875 }
9876 impl CstDecode<crate::bindings::BitcoinAddressData> for *mut wire_cst_bitcoin_address_data {
9877 fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9879 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9880 CstDecode::<crate::bindings::BitcoinAddressData>::cst_decode(*wrap).into()
9881 }
9882 }
9883 impl CstDecode<bool> for *mut bool {
9884 fn cst_decode(self) -> bool {
9886 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9887 }
9888 }
9889 impl CstDecode<crate::model::BuyBitcoinRequest> for *mut wire_cst_buy_bitcoin_request {
9890 fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
9892 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9893 CstDecode::<crate::model::BuyBitcoinRequest>::cst_decode(*wrap).into()
9894 }
9895 }
9896 impl CstDecode<crate::model::CheckMessageRequest> for *mut wire_cst_check_message_request {
9897 fn cst_decode(self) -> crate::model::CheckMessageRequest {
9899 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9900 CstDecode::<crate::model::CheckMessageRequest>::cst_decode(*wrap).into()
9901 }
9902 }
9903 impl CstDecode<crate::model::ConnectRequest> for *mut wire_cst_connect_request {
9904 fn cst_decode(self) -> crate::model::ConnectRequest {
9906 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9907 CstDecode::<crate::model::ConnectRequest>::cst_decode(*wrap).into()
9908 }
9909 }
9910 impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
9911 for *mut wire_cst_create_bolt_12_invoice_request
9912 {
9913 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
9915 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9916 CstDecode::<crate::model::CreateBolt12InvoiceRequest>::cst_decode(*wrap).into()
9917 }
9918 }
9919 impl CstDecode<f64> for *mut f64 {
9920 fn cst_decode(self) -> f64 {
9922 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9923 }
9924 }
9925 impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
9926 for *mut wire_cst_fetch_payment_proposed_fees_request
9927 {
9928 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
9930 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9931 CstDecode::<crate::model::FetchPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9932 }
9933 }
9934 impl CstDecode<crate::model::GetPaymentRequest> for *mut wire_cst_get_payment_request {
9935 fn cst_decode(self) -> crate::model::GetPaymentRequest {
9937 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9938 CstDecode::<crate::model::GetPaymentRequest>::cst_decode(*wrap).into()
9939 }
9940 }
9941 impl CstDecode<i64> for *mut i64 {
9942 fn cst_decode(self) -> i64 {
9944 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9945 }
9946 }
9947 impl CstDecode<crate::bindings::LiquidAddressData> for *mut wire_cst_liquid_address_data {
9948 fn cst_decode(self) -> crate::bindings::LiquidAddressData {
9950 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9951 CstDecode::<crate::bindings::LiquidAddressData>::cst_decode(*wrap).into()
9952 }
9953 }
9954 impl CstDecode<crate::model::ListPaymentDetails> for *mut wire_cst_list_payment_details {
9955 fn cst_decode(self) -> crate::model::ListPaymentDetails {
9957 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9958 CstDecode::<crate::model::ListPaymentDetails>::cst_decode(*wrap).into()
9959 }
9960 }
9961 impl CstDecode<crate::model::ListPaymentsRequest> for *mut wire_cst_list_payments_request {
9962 fn cst_decode(self) -> crate::model::ListPaymentsRequest {
9964 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9965 CstDecode::<crate::model::ListPaymentsRequest>::cst_decode(*wrap).into()
9966 }
9967 }
9968 impl CstDecode<crate::bindings::LNInvoice> for *mut wire_cst_ln_invoice {
9969 fn cst_decode(self) -> crate::bindings::LNInvoice {
9971 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9972 CstDecode::<crate::bindings::LNInvoice>::cst_decode(*wrap).into()
9973 }
9974 }
9975 impl CstDecode<crate::bindings::LNOffer> for *mut wire_cst_ln_offer {
9976 fn cst_decode(self) -> crate::bindings::LNOffer {
9978 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9979 CstDecode::<crate::bindings::LNOffer>::cst_decode(*wrap).into()
9980 }
9981 }
9982 impl CstDecode<crate::bindings::LnUrlAuthRequestData> for *mut wire_cst_ln_url_auth_request_data {
9983 fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
9985 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9986 CstDecode::<crate::bindings::LnUrlAuthRequestData>::cst_decode(*wrap).into()
9987 }
9988 }
9989 impl CstDecode<crate::bindings::LnUrlErrorData> for *mut wire_cst_ln_url_error_data {
9990 fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
9992 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9993 CstDecode::<crate::bindings::LnUrlErrorData>::cst_decode(*wrap).into()
9994 }
9995 }
9996 impl CstDecode<crate::model::LnUrlInfo> for *mut wire_cst_ln_url_info {
9997 fn cst_decode(self) -> crate::model::LnUrlInfo {
9999 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10000 CstDecode::<crate::model::LnUrlInfo>::cst_decode(*wrap).into()
10001 }
10002 }
10003 impl CstDecode<crate::bindings::LnUrlPayErrorData> for *mut wire_cst_ln_url_pay_error_data {
10004 fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10006 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10007 CstDecode::<crate::bindings::LnUrlPayErrorData>::cst_decode(*wrap).into()
10008 }
10009 }
10010 impl CstDecode<crate::model::LnUrlPayRequest> for *mut wire_cst_ln_url_pay_request {
10011 fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10013 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10014 CstDecode::<crate::model::LnUrlPayRequest>::cst_decode(*wrap).into()
10015 }
10016 }
10017 impl CstDecode<crate::bindings::LnUrlPayRequestData> for *mut wire_cst_ln_url_pay_request_data {
10018 fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10020 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10021 CstDecode::<crate::bindings::LnUrlPayRequestData>::cst_decode(*wrap).into()
10022 }
10023 }
10024 impl CstDecode<crate::model::LnUrlPaySuccessData> for *mut wire_cst_ln_url_pay_success_data {
10025 fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10027 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10028 CstDecode::<crate::model::LnUrlPaySuccessData>::cst_decode(*wrap).into()
10029 }
10030 }
10031 impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for *mut wire_cst_ln_url_withdraw_request {
10032 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
10034 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10035 CstDecode::<crate::bindings::LnUrlWithdrawRequest>::cst_decode(*wrap).into()
10036 }
10037 }
10038 impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
10039 for *mut wire_cst_ln_url_withdraw_request_data
10040 {
10041 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
10043 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10044 CstDecode::<crate::bindings::LnUrlWithdrawRequestData>::cst_decode(*wrap).into()
10045 }
10046 }
10047 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
10048 for *mut wire_cst_ln_url_withdraw_success_data
10049 {
10050 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
10052 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10053 CstDecode::<crate::bindings::duplicates::LnUrlWithdrawSuccessData>::cst_decode(*wrap)
10054 .into()
10055 }
10056 }
10057 impl CstDecode<crate::bindings::MessageSuccessActionData>
10058 for *mut wire_cst_message_success_action_data
10059 {
10060 fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
10062 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10063 CstDecode::<crate::bindings::MessageSuccessActionData>::cst_decode(*wrap).into()
10064 }
10065 }
10066 impl CstDecode<crate::model::PayAmount> for *mut wire_cst_pay_amount {
10067 fn cst_decode(self) -> crate::model::PayAmount {
10069 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10070 CstDecode::<crate::model::PayAmount>::cst_decode(*wrap).into()
10071 }
10072 }
10073 impl CstDecode<crate::model::PayOnchainRequest> for *mut wire_cst_pay_onchain_request {
10074 fn cst_decode(self) -> crate::model::PayOnchainRequest {
10076 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10077 CstDecode::<crate::model::PayOnchainRequest>::cst_decode(*wrap).into()
10078 }
10079 }
10080 impl CstDecode<crate::model::Payment> for *mut wire_cst_payment {
10081 fn cst_decode(self) -> crate::model::Payment {
10083 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10084 CstDecode::<crate::model::Payment>::cst_decode(*wrap).into()
10085 }
10086 }
10087 impl CstDecode<crate::model::PrepareBuyBitcoinRequest>
10088 for *mut wire_cst_prepare_buy_bitcoin_request
10089 {
10090 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
10092 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10093 CstDecode::<crate::model::PrepareBuyBitcoinRequest>::cst_decode(*wrap).into()
10094 }
10095 }
10096 impl CstDecode<crate::model::PrepareLnUrlPayRequest> for *mut wire_cst_prepare_ln_url_pay_request {
10097 fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
10099 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10100 CstDecode::<crate::model::PrepareLnUrlPayRequest>::cst_decode(*wrap).into()
10101 }
10102 }
10103 impl CstDecode<crate::model::PreparePayOnchainRequest>
10104 for *mut wire_cst_prepare_pay_onchain_request
10105 {
10106 fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
10108 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10109 CstDecode::<crate::model::PreparePayOnchainRequest>::cst_decode(*wrap).into()
10110 }
10111 }
10112 impl CstDecode<crate::model::PrepareReceiveRequest> for *mut wire_cst_prepare_receive_request {
10113 fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
10115 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10116 CstDecode::<crate::model::PrepareReceiveRequest>::cst_decode(*wrap).into()
10117 }
10118 }
10119 impl CstDecode<crate::model::PrepareRefundRequest> for *mut wire_cst_prepare_refund_request {
10120 fn cst_decode(self) -> crate::model::PrepareRefundRequest {
10122 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10123 CstDecode::<crate::model::PrepareRefundRequest>::cst_decode(*wrap).into()
10124 }
10125 }
10126 impl CstDecode<crate::model::PrepareSendRequest> for *mut wire_cst_prepare_send_request {
10127 fn cst_decode(self) -> crate::model::PrepareSendRequest {
10129 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10130 CstDecode::<crate::model::PrepareSendRequest>::cst_decode(*wrap).into()
10131 }
10132 }
10133 impl CstDecode<crate::model::ReceiveAmount> for *mut wire_cst_receive_amount {
10134 fn cst_decode(self) -> crate::model::ReceiveAmount {
10136 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10137 CstDecode::<crate::model::ReceiveAmount>::cst_decode(*wrap).into()
10138 }
10139 }
10140 impl CstDecode<crate::model::ReceivePaymentRequest> for *mut wire_cst_receive_payment_request {
10141 fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
10143 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10144 CstDecode::<crate::model::ReceivePaymentRequest>::cst_decode(*wrap).into()
10145 }
10146 }
10147 impl CstDecode<crate::model::RefundRequest> for *mut wire_cst_refund_request {
10148 fn cst_decode(self) -> crate::model::RefundRequest {
10150 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10151 CstDecode::<crate::model::RefundRequest>::cst_decode(*wrap).into()
10152 }
10153 }
10154 impl CstDecode<crate::model::RestoreRequest> for *mut wire_cst_restore_request {
10155 fn cst_decode(self) -> crate::model::RestoreRequest {
10157 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10158 CstDecode::<crate::model::RestoreRequest>::cst_decode(*wrap).into()
10159 }
10160 }
10161 impl CstDecode<crate::model::SdkEvent> for *mut wire_cst_sdk_event {
10162 fn cst_decode(self) -> crate::model::SdkEvent {
10164 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10165 CstDecode::<crate::model::SdkEvent>::cst_decode(*wrap).into()
10166 }
10167 }
10168 impl CstDecode<crate::model::SendPaymentRequest> for *mut wire_cst_send_payment_request {
10169 fn cst_decode(self) -> crate::model::SendPaymentRequest {
10171 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10172 CstDecode::<crate::model::SendPaymentRequest>::cst_decode(*wrap).into()
10173 }
10174 }
10175 impl CstDecode<crate::model::SignMessageRequest> for *mut wire_cst_sign_message_request {
10176 fn cst_decode(self) -> crate::model::SignMessageRequest {
10178 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10179 CstDecode::<crate::model::SignMessageRequest>::cst_decode(*wrap).into()
10180 }
10181 }
10182 impl CstDecode<crate::bindings::SuccessAction> for *mut wire_cst_success_action {
10183 fn cst_decode(self) -> crate::bindings::SuccessAction {
10185 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10186 CstDecode::<crate::bindings::SuccessAction>::cst_decode(*wrap).into()
10187 }
10188 }
10189 impl CstDecode<crate::bindings::SuccessActionProcessed> for *mut wire_cst_success_action_processed {
10190 fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
10192 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10193 CstDecode::<crate::bindings::SuccessActionProcessed>::cst_decode(*wrap).into()
10194 }
10195 }
10196 impl CstDecode<crate::bindings::Symbol> for *mut wire_cst_symbol {
10197 fn cst_decode(self) -> crate::bindings::Symbol {
10199 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10200 CstDecode::<crate::bindings::Symbol>::cst_decode(*wrap).into()
10201 }
10202 }
10203 impl CstDecode<u32> for *mut u32 {
10204 fn cst_decode(self) -> u32 {
10206 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10207 }
10208 }
10209 impl CstDecode<u64> for *mut u64 {
10210 fn cst_decode(self) -> u64 {
10212 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10213 }
10214 }
10215 impl CstDecode<crate::bindings::UrlSuccessActionData> for *mut wire_cst_url_success_action_data {
10216 fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
10218 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10219 CstDecode::<crate::bindings::UrlSuccessActionData>::cst_decode(*wrap).into()
10220 }
10221 }
10222 impl CstDecode<crate::model::BuyBitcoinRequest> for wire_cst_buy_bitcoin_request {
10223 fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
10225 crate::model::BuyBitcoinRequest {
10226 prepare_response: self.prepare_response.cst_decode(),
10227 redirect_url: self.redirect_url.cst_decode(),
10228 }
10229 }
10230 }
10231 impl CstDecode<crate::model::CheckMessageRequest> for wire_cst_check_message_request {
10232 fn cst_decode(self) -> crate::model::CheckMessageRequest {
10234 crate::model::CheckMessageRequest {
10235 message: self.message.cst_decode(),
10236 pubkey: self.pubkey.cst_decode(),
10237 signature: self.signature.cst_decode(),
10238 }
10239 }
10240 }
10241 impl CstDecode<crate::model::CheckMessageResponse> for wire_cst_check_message_response {
10242 fn cst_decode(self) -> crate::model::CheckMessageResponse {
10244 crate::model::CheckMessageResponse {
10245 is_valid: self.is_valid.cst_decode(),
10246 }
10247 }
10248 }
10249 impl CstDecode<crate::model::Config> for wire_cst_config {
10250 fn cst_decode(self) -> crate::model::Config {
10252 crate::model::Config {
10253 liquid_explorer: self.liquid_explorer.cst_decode(),
10254 bitcoin_explorer: self.bitcoin_explorer.cst_decode(),
10255 working_dir: self.working_dir.cst_decode(),
10256 network: self.network.cst_decode(),
10257 payment_timeout_sec: self.payment_timeout_sec.cst_decode(),
10258 sync_service_url: self.sync_service_url.cst_decode(),
10259 zero_conf_max_amount_sat: self.zero_conf_max_amount_sat.cst_decode(),
10260 breez_api_key: self.breez_api_key.cst_decode(),
10261 external_input_parsers: self.external_input_parsers.cst_decode(),
10262 use_default_external_input_parsers: self
10263 .use_default_external_input_parsers
10264 .cst_decode(),
10265 onchain_fee_rate_leeway_sat_per_vbyte: self
10266 .onchain_fee_rate_leeway_sat_per_vbyte
10267 .cst_decode(),
10268 asset_metadata: self.asset_metadata.cst_decode(),
10269 sideswap_api_key: self.sideswap_api_key.cst_decode(),
10270 }
10271 }
10272 }
10273 impl CstDecode<crate::model::ConnectRequest> for wire_cst_connect_request {
10274 fn cst_decode(self) -> crate::model::ConnectRequest {
10276 crate::model::ConnectRequest {
10277 config: self.config.cst_decode(),
10278 mnemonic: self.mnemonic.cst_decode(),
10279 passphrase: self.passphrase.cst_decode(),
10280 seed: self.seed.cst_decode(),
10281 }
10282 }
10283 }
10284 impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
10285 for wire_cst_create_bolt_12_invoice_request
10286 {
10287 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
10289 crate::model::CreateBolt12InvoiceRequest {
10290 offer: self.offer.cst_decode(),
10291 invoice_request: self.invoice_request.cst_decode(),
10292 }
10293 }
10294 }
10295 impl CstDecode<crate::model::CreateBolt12InvoiceResponse>
10296 for wire_cst_create_bolt_12_invoice_response
10297 {
10298 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceResponse {
10300 crate::model::CreateBolt12InvoiceResponse {
10301 invoice: self.invoice.cst_decode(),
10302 }
10303 }
10304 }
10305 impl CstDecode<crate::bindings::CurrencyInfo> for wire_cst_currency_info {
10306 fn cst_decode(self) -> crate::bindings::CurrencyInfo {
10308 crate::bindings::CurrencyInfo {
10309 name: self.name.cst_decode(),
10310 fraction_size: self.fraction_size.cst_decode(),
10311 spacing: self.spacing.cst_decode(),
10312 symbol: self.symbol.cst_decode(),
10313 uniq_symbol: self.uniq_symbol.cst_decode(),
10314 localized_name: self.localized_name.cst_decode(),
10315 locale_overrides: self.locale_overrides.cst_decode(),
10316 }
10317 }
10318 }
10319 impl CstDecode<crate::bindings::ExternalInputParser> for wire_cst_external_input_parser {
10320 fn cst_decode(self) -> crate::bindings::ExternalInputParser {
10322 crate::bindings::ExternalInputParser {
10323 provider_id: self.provider_id.cst_decode(),
10324 input_regex: self.input_regex.cst_decode(),
10325 parser_url: self.parser_url.cst_decode(),
10326 }
10327 }
10328 }
10329 impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
10330 for wire_cst_fetch_payment_proposed_fees_request
10331 {
10332 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
10334 crate::model::FetchPaymentProposedFeesRequest {
10335 swap_id: self.swap_id.cst_decode(),
10336 }
10337 }
10338 }
10339 impl CstDecode<crate::model::FetchPaymentProposedFeesResponse>
10340 for wire_cst_fetch_payment_proposed_fees_response
10341 {
10342 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesResponse {
10344 crate::model::FetchPaymentProposedFeesResponse {
10345 swap_id: self.swap_id.cst_decode(),
10346 fees_sat: self.fees_sat.cst_decode(),
10347 payer_amount_sat: self.payer_amount_sat.cst_decode(),
10348 receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
10349 }
10350 }
10351 }
10352 impl CstDecode<crate::bindings::FiatCurrency> for wire_cst_fiat_currency {
10353 fn cst_decode(self) -> crate::bindings::FiatCurrency {
10355 crate::bindings::FiatCurrency {
10356 id: self.id.cst_decode(),
10357 info: self.info.cst_decode(),
10358 }
10359 }
10360 }
10361 impl CstDecode<crate::model::GetInfoResponse> for wire_cst_get_info_response {
10362 fn cst_decode(self) -> crate::model::GetInfoResponse {
10364 crate::model::GetInfoResponse {
10365 wallet_info: self.wallet_info.cst_decode(),
10366 blockchain_info: self.blockchain_info.cst_decode(),
10367 }
10368 }
10369 }
10370 impl CstDecode<crate::model::GetPaymentRequest> for wire_cst_get_payment_request {
10371 fn cst_decode(self) -> crate::model::GetPaymentRequest {
10373 match self.tag {
10374 0 => {
10375 let ans = unsafe { self.kind.PaymentHash };
10376 crate::model::GetPaymentRequest::PaymentHash {
10377 payment_hash: ans.payment_hash.cst_decode(),
10378 }
10379 }
10380 1 => {
10381 let ans = unsafe { self.kind.SwapId };
10382 crate::model::GetPaymentRequest::SwapId {
10383 swap_id: ans.swap_id.cst_decode(),
10384 }
10385 }
10386 _ => unreachable!(),
10387 }
10388 }
10389 }
10390 impl CstDecode<crate::bindings::InputType> for wire_cst_input_type {
10391 fn cst_decode(self) -> crate::bindings::InputType {
10393 match self.tag {
10394 0 => {
10395 let ans = unsafe { self.kind.BitcoinAddress };
10396 crate::bindings::InputType::BitcoinAddress {
10397 address: ans.address.cst_decode(),
10398 }
10399 }
10400 1 => {
10401 let ans = unsafe { self.kind.LiquidAddress };
10402 crate::bindings::InputType::LiquidAddress {
10403 address: ans.address.cst_decode(),
10404 }
10405 }
10406 2 => {
10407 let ans = unsafe { self.kind.Bolt11 };
10408 crate::bindings::InputType::Bolt11 {
10409 invoice: ans.invoice.cst_decode(),
10410 }
10411 }
10412 3 => {
10413 let ans = unsafe { self.kind.Bolt12Offer };
10414 crate::bindings::InputType::Bolt12Offer {
10415 offer: ans.offer.cst_decode(),
10416 bip353_address: ans.bip353_address.cst_decode(),
10417 }
10418 }
10419 4 => {
10420 let ans = unsafe { self.kind.NodeId };
10421 crate::bindings::InputType::NodeId {
10422 node_id: ans.node_id.cst_decode(),
10423 }
10424 }
10425 5 => {
10426 let ans = unsafe { self.kind.Url };
10427 crate::bindings::InputType::Url {
10428 url: ans.url.cst_decode(),
10429 }
10430 }
10431 6 => {
10432 let ans = unsafe { self.kind.LnUrlPay };
10433 crate::bindings::InputType::LnUrlPay {
10434 data: ans.data.cst_decode(),
10435 bip353_address: ans.bip353_address.cst_decode(),
10436 }
10437 }
10438 7 => {
10439 let ans = unsafe { self.kind.LnUrlWithdraw };
10440 crate::bindings::InputType::LnUrlWithdraw {
10441 data: ans.data.cst_decode(),
10442 }
10443 }
10444 8 => {
10445 let ans = unsafe { self.kind.LnUrlAuth };
10446 crate::bindings::InputType::LnUrlAuth {
10447 data: ans.data.cst_decode(),
10448 }
10449 }
10450 9 => {
10451 let ans = unsafe { self.kind.LnUrlError };
10452 crate::bindings::InputType::LnUrlError {
10453 data: ans.data.cst_decode(),
10454 }
10455 }
10456 _ => unreachable!(),
10457 }
10458 }
10459 }
10460 impl CstDecode<crate::model::LightningPaymentLimitsResponse>
10461 for wire_cst_lightning_payment_limits_response
10462 {
10463 fn cst_decode(self) -> crate::model::LightningPaymentLimitsResponse {
10465 crate::model::LightningPaymentLimitsResponse {
10466 send: self.send.cst_decode(),
10467 receive: self.receive.cst_decode(),
10468 }
10469 }
10470 }
10471 impl CstDecode<crate::model::Limits> for wire_cst_limits {
10472 fn cst_decode(self) -> crate::model::Limits {
10474 crate::model::Limits {
10475 min_sat: self.min_sat.cst_decode(),
10476 max_sat: self.max_sat.cst_decode(),
10477 max_zero_conf_sat: self.max_zero_conf_sat.cst_decode(),
10478 }
10479 }
10480 }
10481 impl CstDecode<crate::bindings::LiquidAddressData> for wire_cst_liquid_address_data {
10482 fn cst_decode(self) -> crate::bindings::LiquidAddressData {
10484 crate::bindings::LiquidAddressData {
10485 address: self.address.cst_decode(),
10486 network: self.network.cst_decode(),
10487 asset_id: self.asset_id.cst_decode(),
10488 amount: self.amount.cst_decode(),
10489 amount_sat: self.amount_sat.cst_decode(),
10490 label: self.label.cst_decode(),
10491 message: self.message.cst_decode(),
10492 }
10493 }
10494 }
10495 impl CstDecode<Vec<String>> for *mut wire_cst_list_String {
10496 fn cst_decode(self) -> Vec<String> {
10498 let vec = unsafe {
10499 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10500 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10501 };
10502 vec.into_iter().map(CstDecode::cst_decode).collect()
10503 }
10504 }
10505 impl CstDecode<Vec<crate::model::AssetBalance>> for *mut wire_cst_list_asset_balance {
10506 fn cst_decode(self) -> Vec<crate::model::AssetBalance> {
10508 let vec = unsafe {
10509 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10510 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10511 };
10512 vec.into_iter().map(CstDecode::cst_decode).collect()
10513 }
10514 }
10515 impl CstDecode<Vec<crate::model::AssetMetadata>> for *mut wire_cst_list_asset_metadata {
10516 fn cst_decode(self) -> Vec<crate::model::AssetMetadata> {
10518 let vec = unsafe {
10519 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10520 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10521 };
10522 vec.into_iter().map(CstDecode::cst_decode).collect()
10523 }
10524 }
10525 impl CstDecode<Vec<crate::bindings::ExternalInputParser>>
10526 for *mut wire_cst_list_external_input_parser
10527 {
10528 fn cst_decode(self) -> Vec<crate::bindings::ExternalInputParser> {
10530 let vec = unsafe {
10531 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10532 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10533 };
10534 vec.into_iter().map(CstDecode::cst_decode).collect()
10535 }
10536 }
10537 impl CstDecode<Vec<crate::bindings::FiatCurrency>> for *mut wire_cst_list_fiat_currency {
10538 fn cst_decode(self) -> Vec<crate::bindings::FiatCurrency> {
10540 let vec = unsafe {
10541 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10542 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10543 };
10544 vec.into_iter().map(CstDecode::cst_decode).collect()
10545 }
10546 }
10547 impl CstDecode<Vec<crate::bindings::LnOfferBlindedPath>>
10548 for *mut wire_cst_list_ln_offer_blinded_path
10549 {
10550 fn cst_decode(self) -> Vec<crate::bindings::LnOfferBlindedPath> {
10552 let vec = unsafe {
10553 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10554 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10555 };
10556 vec.into_iter().map(CstDecode::cst_decode).collect()
10557 }
10558 }
10559 impl CstDecode<Vec<crate::bindings::LocaleOverrides>> for *mut wire_cst_list_locale_overrides {
10560 fn cst_decode(self) -> Vec<crate::bindings::LocaleOverrides> {
10562 let vec = unsafe {
10563 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10564 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10565 };
10566 vec.into_iter().map(CstDecode::cst_decode).collect()
10567 }
10568 }
10569 impl CstDecode<Vec<crate::bindings::LocalizedName>> for *mut wire_cst_list_localized_name {
10570 fn cst_decode(self) -> Vec<crate::bindings::LocalizedName> {
10572 let vec = unsafe {
10573 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10574 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10575 };
10576 vec.into_iter().map(CstDecode::cst_decode).collect()
10577 }
10578 }
10579 impl CstDecode<Vec<crate::model::Payment>> for *mut wire_cst_list_payment {
10580 fn cst_decode(self) -> Vec<crate::model::Payment> {
10582 let vec = unsafe {
10583 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10584 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10585 };
10586 vec.into_iter().map(CstDecode::cst_decode).collect()
10587 }
10588 }
10589 impl CstDecode<crate::model::ListPaymentDetails> for wire_cst_list_payment_details {
10590 fn cst_decode(self) -> crate::model::ListPaymentDetails {
10592 match self.tag {
10593 0 => {
10594 let ans = unsafe { self.kind.Liquid };
10595 crate::model::ListPaymentDetails::Liquid {
10596 asset_id: ans.asset_id.cst_decode(),
10597 destination: ans.destination.cst_decode(),
10598 }
10599 }
10600 1 => {
10601 let ans = unsafe { self.kind.Bitcoin };
10602 crate::model::ListPaymentDetails::Bitcoin {
10603 address: ans.address.cst_decode(),
10604 }
10605 }
10606 _ => unreachable!(),
10607 }
10608 }
10609 }
10610 impl CstDecode<Vec<crate::model::PaymentState>> for *mut wire_cst_list_payment_state {
10611 fn cst_decode(self) -> Vec<crate::model::PaymentState> {
10613 let vec = unsafe {
10614 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10615 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10616 };
10617 vec.into_iter().map(CstDecode::cst_decode).collect()
10618 }
10619 }
10620 impl CstDecode<Vec<crate::model::PaymentType>> for *mut wire_cst_list_payment_type {
10621 fn cst_decode(self) -> Vec<crate::model::PaymentType> {
10623 let vec = unsafe {
10624 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10625 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10626 };
10627 vec.into_iter().map(CstDecode::cst_decode).collect()
10628 }
10629 }
10630 impl CstDecode<crate::model::ListPaymentsRequest> for wire_cst_list_payments_request {
10631 fn cst_decode(self) -> crate::model::ListPaymentsRequest {
10633 crate::model::ListPaymentsRequest {
10634 filters: self.filters.cst_decode(),
10635 states: self.states.cst_decode(),
10636 from_timestamp: self.from_timestamp.cst_decode(),
10637 to_timestamp: self.to_timestamp.cst_decode(),
10638 offset: self.offset.cst_decode(),
10639 limit: self.limit.cst_decode(),
10640 details: self.details.cst_decode(),
10641 sort_ascending: self.sort_ascending.cst_decode(),
10642 }
10643 }
10644 }
10645 impl CstDecode<Vec<u8>> for *mut wire_cst_list_prim_u_8_strict {
10646 fn cst_decode(self) -> Vec<u8> {
10648 unsafe {
10649 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10650 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10651 }
10652 }
10653 }
10654 impl CstDecode<Vec<crate::bindings::Rate>> for *mut wire_cst_list_rate {
10655 fn cst_decode(self) -> Vec<crate::bindings::Rate> {
10657 let vec = unsafe {
10658 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10659 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10660 };
10661 vec.into_iter().map(CstDecode::cst_decode).collect()
10662 }
10663 }
10664 impl CstDecode<Vec<crate::model::RefundableSwap>> for *mut wire_cst_list_refundable_swap {
10665 fn cst_decode(self) -> Vec<crate::model::RefundableSwap> {
10667 let vec = unsafe {
10668 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10669 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10670 };
10671 vec.into_iter().map(CstDecode::cst_decode).collect()
10672 }
10673 }
10674 impl CstDecode<Vec<crate::bindings::RouteHint>> for *mut wire_cst_list_route_hint {
10675 fn cst_decode(self) -> Vec<crate::bindings::RouteHint> {
10677 let vec = unsafe {
10678 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10679 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10680 };
10681 vec.into_iter().map(CstDecode::cst_decode).collect()
10682 }
10683 }
10684 impl CstDecode<Vec<crate::bindings::RouteHintHop>> for *mut wire_cst_list_route_hint_hop {
10685 fn cst_decode(self) -> Vec<crate::bindings::RouteHintHop> {
10687 let vec = unsafe {
10688 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10689 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10690 };
10691 vec.into_iter().map(CstDecode::cst_decode).collect()
10692 }
10693 }
10694 impl CstDecode<crate::bindings::LNInvoice> for wire_cst_ln_invoice {
10695 fn cst_decode(self) -> crate::bindings::LNInvoice {
10697 crate::bindings::LNInvoice {
10698 bolt11: self.bolt11.cst_decode(),
10699 network: self.network.cst_decode(),
10700 payee_pubkey: self.payee_pubkey.cst_decode(),
10701 payment_hash: self.payment_hash.cst_decode(),
10702 description: self.description.cst_decode(),
10703 description_hash: self.description_hash.cst_decode(),
10704 amount_msat: self.amount_msat.cst_decode(),
10705 timestamp: self.timestamp.cst_decode(),
10706 expiry: self.expiry.cst_decode(),
10707 routing_hints: self.routing_hints.cst_decode(),
10708 payment_secret: self.payment_secret.cst_decode(),
10709 min_final_cltv_expiry_delta: self.min_final_cltv_expiry_delta.cst_decode(),
10710 }
10711 }
10712 }
10713 impl CstDecode<crate::bindings::LNOffer> for wire_cst_ln_offer {
10714 fn cst_decode(self) -> crate::bindings::LNOffer {
10716 crate::bindings::LNOffer {
10717 offer: self.offer.cst_decode(),
10718 chains: self.chains.cst_decode(),
10719 min_amount: self.min_amount.cst_decode(),
10720 description: self.description.cst_decode(),
10721 absolute_expiry: self.absolute_expiry.cst_decode(),
10722 issuer: self.issuer.cst_decode(),
10723 signing_pubkey: self.signing_pubkey.cst_decode(),
10724 paths: self.paths.cst_decode(),
10725 }
10726 }
10727 }
10728 impl CstDecode<crate::bindings::LnOfferBlindedPath> for wire_cst_ln_offer_blinded_path {
10729 fn cst_decode(self) -> crate::bindings::LnOfferBlindedPath {
10731 crate::bindings::LnOfferBlindedPath {
10732 blinded_hops: self.blinded_hops.cst_decode(),
10733 }
10734 }
10735 }
10736 impl CstDecode<crate::bindings::duplicates::LnUrlAuthError> for wire_cst_ln_url_auth_error {
10737 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlAuthError {
10739 match self.tag {
10740 0 => {
10741 let ans = unsafe { self.kind.Generic };
10742 crate::bindings::duplicates::LnUrlAuthError::Generic {
10743 err: ans.err.cst_decode(),
10744 }
10745 }
10746 1 => {
10747 let ans = unsafe { self.kind.InvalidUri };
10748 crate::bindings::duplicates::LnUrlAuthError::InvalidUri {
10749 err: ans.err.cst_decode(),
10750 }
10751 }
10752 2 => {
10753 let ans = unsafe { self.kind.ServiceConnectivity };
10754 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
10755 err: ans.err.cst_decode(),
10756 }
10757 }
10758 _ => unreachable!(),
10759 }
10760 }
10761 }
10762 impl CstDecode<crate::bindings::LnUrlAuthRequestData> for wire_cst_ln_url_auth_request_data {
10763 fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10765 crate::bindings::LnUrlAuthRequestData {
10766 k1: self.k1.cst_decode(),
10767 action: self.action.cst_decode(),
10768 domain: self.domain.cst_decode(),
10769 url: self.url.cst_decode(),
10770 }
10771 }
10772 }
10773 impl CstDecode<crate::bindings::duplicates::LnUrlCallbackStatus>
10774 for wire_cst_ln_url_callback_status
10775 {
10776 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
10778 match self.tag {
10779 0 => crate::bindings::duplicates::LnUrlCallbackStatus::Ok,
10780 1 => {
10781 let ans = unsafe { self.kind.ErrorStatus };
10782 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
10783 data: ans.data.cst_decode(),
10784 }
10785 }
10786 _ => unreachable!(),
10787 }
10788 }
10789 }
10790 impl CstDecode<crate::bindings::LnUrlErrorData> for wire_cst_ln_url_error_data {
10791 fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10793 crate::bindings::LnUrlErrorData {
10794 reason: self.reason.cst_decode(),
10795 }
10796 }
10797 }
10798 impl CstDecode<crate::model::LnUrlInfo> for wire_cst_ln_url_info {
10799 fn cst_decode(self) -> crate::model::LnUrlInfo {
10801 crate::model::LnUrlInfo {
10802 ln_address: self.ln_address.cst_decode(),
10803 lnurl_pay_comment: self.lnurl_pay_comment.cst_decode(),
10804 lnurl_pay_domain: self.lnurl_pay_domain.cst_decode(),
10805 lnurl_pay_metadata: self.lnurl_pay_metadata.cst_decode(),
10806 lnurl_pay_success_action: self.lnurl_pay_success_action.cst_decode(),
10807 lnurl_pay_unprocessed_success_action: self
10808 .lnurl_pay_unprocessed_success_action
10809 .cst_decode(),
10810 lnurl_withdraw_endpoint: self.lnurl_withdraw_endpoint.cst_decode(),
10811 }
10812 }
10813 }
10814 impl CstDecode<crate::bindings::duplicates::LnUrlPayError> for wire_cst_ln_url_pay_error {
10815 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlPayError {
10817 match self.tag {
10818 0 => crate::bindings::duplicates::LnUrlPayError::AlreadyPaid,
10819 1 => {
10820 let ans = unsafe { self.kind.Generic };
10821 crate::bindings::duplicates::LnUrlPayError::Generic {
10822 err: ans.err.cst_decode(),
10823 }
10824 }
10825 2 => {
10826 let ans = unsafe { self.kind.InsufficientBalance };
10827 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
10828 err: ans.err.cst_decode(),
10829 }
10830 }
10831 3 => {
10832 let ans = unsafe { self.kind.InvalidAmount };
10833 crate::bindings::duplicates::LnUrlPayError::InvalidAmount {
10834 err: ans.err.cst_decode(),
10835 }
10836 }
10837 4 => {
10838 let ans = unsafe { self.kind.InvalidInvoice };
10839 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice {
10840 err: ans.err.cst_decode(),
10841 }
10842 }
10843 5 => {
10844 let ans = unsafe { self.kind.InvalidNetwork };
10845 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork {
10846 err: ans.err.cst_decode(),
10847 }
10848 }
10849 6 => {
10850 let ans = unsafe { self.kind.InvalidUri };
10851 crate::bindings::duplicates::LnUrlPayError::InvalidUri {
10852 err: ans.err.cst_decode(),
10853 }
10854 }
10855 7 => {
10856 let ans = unsafe { self.kind.InvoiceExpired };
10857 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired {
10858 err: ans.err.cst_decode(),
10859 }
10860 }
10861 8 => {
10862 let ans = unsafe { self.kind.PaymentFailed };
10863 crate::bindings::duplicates::LnUrlPayError::PaymentFailed {
10864 err: ans.err.cst_decode(),
10865 }
10866 }
10867 9 => {
10868 let ans = unsafe { self.kind.PaymentTimeout };
10869 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout {
10870 err: ans.err.cst_decode(),
10871 }
10872 }
10873 10 => {
10874 let ans = unsafe { self.kind.RouteNotFound };
10875 crate::bindings::duplicates::LnUrlPayError::RouteNotFound {
10876 err: ans.err.cst_decode(),
10877 }
10878 }
10879 11 => {
10880 let ans = unsafe { self.kind.RouteTooExpensive };
10881 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
10882 err: ans.err.cst_decode(),
10883 }
10884 }
10885 12 => {
10886 let ans = unsafe { self.kind.ServiceConnectivity };
10887 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
10888 err: ans.err.cst_decode(),
10889 }
10890 }
10891 _ => unreachable!(),
10892 }
10893 }
10894 }
10895 impl CstDecode<crate::bindings::LnUrlPayErrorData> for wire_cst_ln_url_pay_error_data {
10896 fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10898 crate::bindings::LnUrlPayErrorData {
10899 payment_hash: self.payment_hash.cst_decode(),
10900 reason: self.reason.cst_decode(),
10901 }
10902 }
10903 }
10904 impl CstDecode<crate::model::LnUrlPayRequest> for wire_cst_ln_url_pay_request {
10905 fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10907 crate::model::LnUrlPayRequest {
10908 prepare_response: self.prepare_response.cst_decode(),
10909 }
10910 }
10911 }
10912 impl CstDecode<crate::bindings::LnUrlPayRequestData> for wire_cst_ln_url_pay_request_data {
10913 fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10915 crate::bindings::LnUrlPayRequestData {
10916 callback: self.callback.cst_decode(),
10917 min_sendable: self.min_sendable.cst_decode(),
10918 max_sendable: self.max_sendable.cst_decode(),
10919 metadata_str: self.metadata_str.cst_decode(),
10920 comment_allowed: self.comment_allowed.cst_decode(),
10921 domain: self.domain.cst_decode(),
10922 allows_nostr: self.allows_nostr.cst_decode(),
10923 nostr_pubkey: self.nostr_pubkey.cst_decode(),
10924 ln_address: self.ln_address.cst_decode(),
10925 }
10926 }
10927 }
10928 impl CstDecode<crate::model::LnUrlPayResult> for wire_cst_ln_url_pay_result {
10929 fn cst_decode(self) -> crate::model::LnUrlPayResult {
10931 match self.tag {
10932 0 => {
10933 let ans = unsafe { self.kind.EndpointSuccess };
10934 crate::model::LnUrlPayResult::EndpointSuccess {
10935 data: ans.data.cst_decode(),
10936 }
10937 }
10938 1 => {
10939 let ans = unsafe { self.kind.EndpointError };
10940 crate::model::LnUrlPayResult::EndpointError {
10941 data: ans.data.cst_decode(),
10942 }
10943 }
10944 2 => {
10945 let ans = unsafe { self.kind.PayError };
10946 crate::model::LnUrlPayResult::PayError {
10947 data: ans.data.cst_decode(),
10948 }
10949 }
10950 _ => unreachable!(),
10951 }
10952 }
10953 }
10954 impl CstDecode<crate::model::LnUrlPaySuccessData> for wire_cst_ln_url_pay_success_data {
10955 fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10957 crate::model::LnUrlPaySuccessData {
10958 payment: self.payment.cst_decode(),
10959 success_action: self.success_action.cst_decode(),
10960 }
10961 }
10962 }
10963 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawError> for wire_cst_ln_url_withdraw_error {
10964 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
10966 match self.tag {
10967 0 => {
10968 let ans = unsafe { self.kind.Generic };
10969 crate::bindings::duplicates::LnUrlWithdrawError::Generic {
10970 err: ans.err.cst_decode(),
10971 }
10972 }
10973 1 => {
10974 let ans = unsafe { self.kind.InvalidAmount };
10975 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
10976 err: ans.err.cst_decode(),
10977 }
10978 }
10979 2 => {
10980 let ans = unsafe { self.kind.InvalidInvoice };
10981 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
10982 err: ans.err.cst_decode(),
10983 }
10984 }
10985 3 => {
10986 let ans = unsafe { self.kind.InvalidUri };
10987 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
10988 err: ans.err.cst_decode(),
10989 }
10990 }
10991 4 => {
10992 let ans = unsafe { self.kind.InvoiceNoRoutingHints };
10993 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
10994 err: ans.err.cst_decode(),
10995 }
10996 }
10997 5 => {
10998 let ans = unsafe { self.kind.ServiceConnectivity };
10999 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
11000 err: ans.err.cst_decode(),
11001 }
11002 }
11003 _ => unreachable!(),
11004 }
11005 }
11006 }
11007 impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for wire_cst_ln_url_withdraw_request {
11008 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
11010 crate::bindings::LnUrlWithdrawRequest {
11011 data: self.data.cst_decode(),
11012 amount_msat: self.amount_msat.cst_decode(),
11013 description: self.description.cst_decode(),
11014 }
11015 }
11016 }
11017 impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
11018 for wire_cst_ln_url_withdraw_request_data
11019 {
11020 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
11022 crate::bindings::LnUrlWithdrawRequestData {
11023 callback: self.callback.cst_decode(),
11024 k1: self.k1.cst_decode(),
11025 default_description: self.default_description.cst_decode(),
11026 min_withdrawable: self.min_withdrawable.cst_decode(),
11027 max_withdrawable: self.max_withdrawable.cst_decode(),
11028 }
11029 }
11030 }
11031 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawResult>
11032 for wire_cst_ln_url_withdraw_result
11033 {
11034 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
11036 match self.tag {
11037 0 => {
11038 let ans = unsafe { self.kind.Ok };
11039 crate::bindings::duplicates::LnUrlWithdrawResult::Ok {
11040 data: ans.data.cst_decode(),
11041 }
11042 }
11043 1 => {
11044 let ans = unsafe { self.kind.Timeout };
11045 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
11046 data: ans.data.cst_decode(),
11047 }
11048 }
11049 2 => {
11050 let ans = unsafe { self.kind.ErrorStatus };
11051 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
11052 data: ans.data.cst_decode(),
11053 }
11054 }
11055 _ => unreachable!(),
11056 }
11057 }
11058 }
11059 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
11060 for wire_cst_ln_url_withdraw_success_data
11061 {
11062 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11064 crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11065 invoice: self.invoice.cst_decode(),
11066 }
11067 }
11068 }
11069 impl CstDecode<crate::bindings::LocaleOverrides> for wire_cst_locale_overrides {
11070 fn cst_decode(self) -> crate::bindings::LocaleOverrides {
11072 crate::bindings::LocaleOverrides {
11073 locale: self.locale.cst_decode(),
11074 spacing: self.spacing.cst_decode(),
11075 symbol: self.symbol.cst_decode(),
11076 }
11077 }
11078 }
11079 impl CstDecode<crate::bindings::LocalizedName> for wire_cst_localized_name {
11080 fn cst_decode(self) -> crate::bindings::LocalizedName {
11082 crate::bindings::LocalizedName {
11083 locale: self.locale.cst_decode(),
11084 name: self.name.cst_decode(),
11085 }
11086 }
11087 }
11088 impl CstDecode<crate::model::LogEntry> for wire_cst_log_entry {
11089 fn cst_decode(self) -> crate::model::LogEntry {
11091 crate::model::LogEntry {
11092 line: self.line.cst_decode(),
11093 level: self.level.cst_decode(),
11094 }
11095 }
11096 }
11097 impl CstDecode<crate::bindings::MessageSuccessActionData> for wire_cst_message_success_action_data {
11098 fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
11100 crate::bindings::MessageSuccessActionData {
11101 message: self.message.cst_decode(),
11102 }
11103 }
11104 }
11105 impl CstDecode<crate::model::OnchainPaymentLimitsResponse>
11106 for wire_cst_onchain_payment_limits_response
11107 {
11108 fn cst_decode(self) -> crate::model::OnchainPaymentLimitsResponse {
11110 crate::model::OnchainPaymentLimitsResponse {
11111 send: self.send.cst_decode(),
11112 receive: self.receive.cst_decode(),
11113 }
11114 }
11115 }
11116 impl CstDecode<crate::model::PayAmount> for wire_cst_pay_amount {
11117 fn cst_decode(self) -> crate::model::PayAmount {
11119 match self.tag {
11120 0 => {
11121 let ans = unsafe { self.kind.Bitcoin };
11122 crate::model::PayAmount::Bitcoin {
11123 receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11124 }
11125 }
11126 1 => {
11127 let ans = unsafe { self.kind.Asset };
11128 crate::model::PayAmount::Asset {
11129 asset_id: ans.asset_id.cst_decode(),
11130 receiver_amount: ans.receiver_amount.cst_decode(),
11131 estimate_asset_fees: ans.estimate_asset_fees.cst_decode(),
11132 }
11133 }
11134 2 => crate::model::PayAmount::Drain,
11135 _ => unreachable!(),
11136 }
11137 }
11138 }
11139 impl CstDecode<crate::model::PayOnchainRequest> for wire_cst_pay_onchain_request {
11140 fn cst_decode(self) -> crate::model::PayOnchainRequest {
11142 crate::model::PayOnchainRequest {
11143 address: self.address.cst_decode(),
11144 prepare_response: self.prepare_response.cst_decode(),
11145 }
11146 }
11147 }
11148 impl CstDecode<crate::model::Payment> for wire_cst_payment {
11149 fn cst_decode(self) -> crate::model::Payment {
11151 crate::model::Payment {
11152 destination: self.destination.cst_decode(),
11153 tx_id: self.tx_id.cst_decode(),
11154 unblinding_data: self.unblinding_data.cst_decode(),
11155 timestamp: self.timestamp.cst_decode(),
11156 amount_sat: self.amount_sat.cst_decode(),
11157 fees_sat: self.fees_sat.cst_decode(),
11158 swapper_fees_sat: self.swapper_fees_sat.cst_decode(),
11159 payment_type: self.payment_type.cst_decode(),
11160 status: self.status.cst_decode(),
11161 details: self.details.cst_decode(),
11162 }
11163 }
11164 }
11165 impl CstDecode<crate::model::PaymentDetails> for wire_cst_payment_details {
11166 fn cst_decode(self) -> crate::model::PaymentDetails {
11168 match self.tag {
11169 0 => {
11170 let ans = unsafe { self.kind.Lightning };
11171 crate::model::PaymentDetails::Lightning {
11172 swap_id: ans.swap_id.cst_decode(),
11173 description: ans.description.cst_decode(),
11174 liquid_expiration_blockheight: ans
11175 .liquid_expiration_blockheight
11176 .cst_decode(),
11177 preimage: ans.preimage.cst_decode(),
11178 invoice: ans.invoice.cst_decode(),
11179 bolt12_offer: ans.bolt12_offer.cst_decode(),
11180 payment_hash: ans.payment_hash.cst_decode(),
11181 destination_pubkey: ans.destination_pubkey.cst_decode(),
11182 lnurl_info: ans.lnurl_info.cst_decode(),
11183 bip353_address: ans.bip353_address.cst_decode(),
11184 claim_tx_id: ans.claim_tx_id.cst_decode(),
11185 refund_tx_id: ans.refund_tx_id.cst_decode(),
11186 refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11187 }
11188 }
11189 1 => {
11190 let ans = unsafe { self.kind.Liquid };
11191 crate::model::PaymentDetails::Liquid {
11192 destination: ans.destination.cst_decode(),
11193 description: ans.description.cst_decode(),
11194 asset_id: ans.asset_id.cst_decode(),
11195 asset_info: ans.asset_info.cst_decode(),
11196 lnurl_info: ans.lnurl_info.cst_decode(),
11197 bip353_address: ans.bip353_address.cst_decode(),
11198 }
11199 }
11200 2 => {
11201 let ans = unsafe { self.kind.Bitcoin };
11202 crate::model::PaymentDetails::Bitcoin {
11203 swap_id: ans.swap_id.cst_decode(),
11204 bitcoin_address: ans.bitcoin_address.cst_decode(),
11205 description: ans.description.cst_decode(),
11206 auto_accepted_fees: ans.auto_accepted_fees.cst_decode(),
11207 liquid_expiration_blockheight: ans
11208 .liquid_expiration_blockheight
11209 .cst_decode(),
11210 bitcoin_expiration_blockheight: ans
11211 .bitcoin_expiration_blockheight
11212 .cst_decode(),
11213 lockup_tx_id: ans.lockup_tx_id.cst_decode(),
11214 claim_tx_id: ans.claim_tx_id.cst_decode(),
11215 refund_tx_id: ans.refund_tx_id.cst_decode(),
11216 refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11217 }
11218 }
11219 _ => unreachable!(),
11220 }
11221 }
11222 }
11223 impl CstDecode<crate::error::PaymentError> for wire_cst_payment_error {
11224 fn cst_decode(self) -> crate::error::PaymentError {
11226 match self.tag {
11227 0 => crate::error::PaymentError::AlreadyClaimed,
11228 1 => crate::error::PaymentError::AlreadyPaid,
11229 2 => crate::error::PaymentError::PaymentInProgress,
11230 3 => {
11231 let ans = unsafe { self.kind.AmountOutOfRange };
11232 crate::error::PaymentError::AmountOutOfRange {
11233 min: ans.min.cst_decode(),
11234 max: ans.max.cst_decode(),
11235 }
11236 }
11237 4 => {
11238 let ans = unsafe { self.kind.AmountMissing };
11239 crate::error::PaymentError::AmountMissing {
11240 err: ans.err.cst_decode(),
11241 }
11242 }
11243 5 => {
11244 let ans = unsafe { self.kind.AssetError };
11245 crate::error::PaymentError::AssetError {
11246 err: ans.err.cst_decode(),
11247 }
11248 }
11249 6 => {
11250 let ans = unsafe { self.kind.InvalidNetwork };
11251 crate::error::PaymentError::InvalidNetwork {
11252 err: ans.err.cst_decode(),
11253 }
11254 }
11255 7 => {
11256 let ans = unsafe { self.kind.Generic };
11257 crate::error::PaymentError::Generic {
11258 err: ans.err.cst_decode(),
11259 }
11260 }
11261 8 => crate::error::PaymentError::InvalidOrExpiredFees,
11262 9 => crate::error::PaymentError::InsufficientFunds,
11263 10 => {
11264 let ans = unsafe { self.kind.InvalidDescription };
11265 crate::error::PaymentError::InvalidDescription {
11266 err: ans.err.cst_decode(),
11267 }
11268 }
11269 11 => {
11270 let ans = unsafe { self.kind.InvalidInvoice };
11271 crate::error::PaymentError::InvalidInvoice {
11272 err: ans.err.cst_decode(),
11273 }
11274 }
11275 12 => crate::error::PaymentError::InvalidPreimage,
11276 13 => crate::error::PaymentError::PairsNotFound,
11277 14 => crate::error::PaymentError::PaymentTimeout,
11278 15 => crate::error::PaymentError::PersistError,
11279 16 => {
11280 let ans = unsafe { self.kind.ReceiveError };
11281 crate::error::PaymentError::ReceiveError {
11282 err: ans.err.cst_decode(),
11283 }
11284 }
11285 17 => {
11286 let ans = unsafe { self.kind.Refunded };
11287 crate::error::PaymentError::Refunded {
11288 err: ans.err.cst_decode(),
11289 refund_tx_id: ans.refund_tx_id.cst_decode(),
11290 }
11291 }
11292 18 => crate::error::PaymentError::SelfTransferNotSupported,
11293 19 => {
11294 let ans = unsafe { self.kind.SendError };
11295 crate::error::PaymentError::SendError {
11296 err: ans.err.cst_decode(),
11297 }
11298 }
11299 20 => {
11300 let ans = unsafe { self.kind.SignerError };
11301 crate::error::PaymentError::SignerError {
11302 err: ans.err.cst_decode(),
11303 }
11304 }
11305 _ => unreachable!(),
11306 }
11307 }
11308 }
11309 impl CstDecode<crate::model::PrepareBuyBitcoinRequest> for wire_cst_prepare_buy_bitcoin_request {
11310 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
11312 crate::model::PrepareBuyBitcoinRequest {
11313 provider: self.provider.cst_decode(),
11314 amount_sat: self.amount_sat.cst_decode(),
11315 }
11316 }
11317 }
11318 impl CstDecode<crate::model::PrepareBuyBitcoinResponse> for wire_cst_prepare_buy_bitcoin_response {
11319 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinResponse {
11321 crate::model::PrepareBuyBitcoinResponse {
11322 provider: self.provider.cst_decode(),
11323 amount_sat: self.amount_sat.cst_decode(),
11324 fees_sat: self.fees_sat.cst_decode(),
11325 }
11326 }
11327 }
11328 impl CstDecode<crate::model::PrepareLnUrlPayRequest> for wire_cst_prepare_ln_url_pay_request {
11329 fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
11331 crate::model::PrepareLnUrlPayRequest {
11332 data: self.data.cst_decode(),
11333 amount: self.amount.cst_decode(),
11334 bip353_address: self.bip353_address.cst_decode(),
11335 comment: self.comment.cst_decode(),
11336 validate_success_action_url: self.validate_success_action_url.cst_decode(),
11337 }
11338 }
11339 }
11340 impl CstDecode<crate::model::PrepareLnUrlPayResponse> for wire_cst_prepare_ln_url_pay_response {
11341 fn cst_decode(self) -> crate::model::PrepareLnUrlPayResponse {
11343 crate::model::PrepareLnUrlPayResponse {
11344 destination: self.destination.cst_decode(),
11345 fees_sat: self.fees_sat.cst_decode(),
11346 data: self.data.cst_decode(),
11347 amount: self.amount.cst_decode(),
11348 comment: self.comment.cst_decode(),
11349 success_action: self.success_action.cst_decode(),
11350 }
11351 }
11352 }
11353 impl CstDecode<crate::model::PreparePayOnchainRequest> for wire_cst_prepare_pay_onchain_request {
11354 fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
11356 crate::model::PreparePayOnchainRequest {
11357 amount: self.amount.cst_decode(),
11358 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11359 }
11360 }
11361 }
11362 impl CstDecode<crate::model::PreparePayOnchainResponse> for wire_cst_prepare_pay_onchain_response {
11363 fn cst_decode(self) -> crate::model::PreparePayOnchainResponse {
11365 crate::model::PreparePayOnchainResponse {
11366 receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
11367 claim_fees_sat: self.claim_fees_sat.cst_decode(),
11368 total_fees_sat: self.total_fees_sat.cst_decode(),
11369 }
11370 }
11371 }
11372 impl CstDecode<crate::model::PrepareReceiveRequest> for wire_cst_prepare_receive_request {
11373 fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
11375 crate::model::PrepareReceiveRequest {
11376 payment_method: self.payment_method.cst_decode(),
11377 amount: self.amount.cst_decode(),
11378 }
11379 }
11380 }
11381 impl CstDecode<crate::model::PrepareReceiveResponse> for wire_cst_prepare_receive_response {
11382 fn cst_decode(self) -> crate::model::PrepareReceiveResponse {
11384 crate::model::PrepareReceiveResponse {
11385 payment_method: self.payment_method.cst_decode(),
11386 fees_sat: self.fees_sat.cst_decode(),
11387 amount: self.amount.cst_decode(),
11388 min_payer_amount_sat: self.min_payer_amount_sat.cst_decode(),
11389 max_payer_amount_sat: self.max_payer_amount_sat.cst_decode(),
11390 swapper_feerate: self.swapper_feerate.cst_decode(),
11391 }
11392 }
11393 }
11394 impl CstDecode<crate::model::PrepareRefundRequest> for wire_cst_prepare_refund_request {
11395 fn cst_decode(self) -> crate::model::PrepareRefundRequest {
11397 crate::model::PrepareRefundRequest {
11398 swap_address: self.swap_address.cst_decode(),
11399 refund_address: self.refund_address.cst_decode(),
11400 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11401 }
11402 }
11403 }
11404 impl CstDecode<crate::model::PrepareRefundResponse> for wire_cst_prepare_refund_response {
11405 fn cst_decode(self) -> crate::model::PrepareRefundResponse {
11407 crate::model::PrepareRefundResponse {
11408 tx_vsize: self.tx_vsize.cst_decode(),
11409 tx_fee_sat: self.tx_fee_sat.cst_decode(),
11410 last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11411 }
11412 }
11413 }
11414 impl CstDecode<crate::model::PrepareSendRequest> for wire_cst_prepare_send_request {
11415 fn cst_decode(self) -> crate::model::PrepareSendRequest {
11417 crate::model::PrepareSendRequest {
11418 destination: self.destination.cst_decode(),
11419 amount: self.amount.cst_decode(),
11420 comment: self.comment.cst_decode(),
11421 }
11422 }
11423 }
11424 impl CstDecode<crate::model::PrepareSendResponse> for wire_cst_prepare_send_response {
11425 fn cst_decode(self) -> crate::model::PrepareSendResponse {
11427 crate::model::PrepareSendResponse {
11428 destination: self.destination.cst_decode(),
11429 amount: self.amount.cst_decode(),
11430 fees_sat: self.fees_sat.cst_decode(),
11431 estimated_asset_fees: self.estimated_asset_fees.cst_decode(),
11432 }
11433 }
11434 }
11435 impl CstDecode<crate::bindings::Rate> for wire_cst_rate {
11436 fn cst_decode(self) -> crate::bindings::Rate {
11438 crate::bindings::Rate {
11439 coin: self.coin.cst_decode(),
11440 value: self.value.cst_decode(),
11441 }
11442 }
11443 }
11444 impl CstDecode<crate::model::ReceiveAmount> for wire_cst_receive_amount {
11445 fn cst_decode(self) -> crate::model::ReceiveAmount {
11447 match self.tag {
11448 0 => {
11449 let ans = unsafe { self.kind.Bitcoin };
11450 crate::model::ReceiveAmount::Bitcoin {
11451 payer_amount_sat: ans.payer_amount_sat.cst_decode(),
11452 }
11453 }
11454 1 => {
11455 let ans = unsafe { self.kind.Asset };
11456 crate::model::ReceiveAmount::Asset {
11457 asset_id: ans.asset_id.cst_decode(),
11458 payer_amount: ans.payer_amount.cst_decode(),
11459 }
11460 }
11461 _ => unreachable!(),
11462 }
11463 }
11464 }
11465 impl CstDecode<crate::model::ReceivePaymentRequest> for wire_cst_receive_payment_request {
11466 fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
11468 crate::model::ReceivePaymentRequest {
11469 prepare_response: self.prepare_response.cst_decode(),
11470 description: self.description.cst_decode(),
11471 use_description_hash: self.use_description_hash.cst_decode(),
11472 }
11473 }
11474 }
11475 impl CstDecode<crate::model::ReceivePaymentResponse> for wire_cst_receive_payment_response {
11476 fn cst_decode(self) -> crate::model::ReceivePaymentResponse {
11478 crate::model::ReceivePaymentResponse {
11479 destination: self.destination.cst_decode(),
11480 }
11481 }
11482 }
11483 impl CstDecode<crate::model::RecommendedFees> for wire_cst_recommended_fees {
11484 fn cst_decode(self) -> crate::model::RecommendedFees {
11486 crate::model::RecommendedFees {
11487 fastest_fee: self.fastest_fee.cst_decode(),
11488 half_hour_fee: self.half_hour_fee.cst_decode(),
11489 hour_fee: self.hour_fee.cst_decode(),
11490 economy_fee: self.economy_fee.cst_decode(),
11491 minimum_fee: self.minimum_fee.cst_decode(),
11492 }
11493 }
11494 }
11495 impl CstDecode<crate::model::RefundRequest> for wire_cst_refund_request {
11496 fn cst_decode(self) -> crate::model::RefundRequest {
11498 crate::model::RefundRequest {
11499 swap_address: self.swap_address.cst_decode(),
11500 refund_address: self.refund_address.cst_decode(),
11501 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11502 }
11503 }
11504 }
11505 impl CstDecode<crate::model::RefundResponse> for wire_cst_refund_response {
11506 fn cst_decode(self) -> crate::model::RefundResponse {
11508 crate::model::RefundResponse {
11509 refund_tx_id: self.refund_tx_id.cst_decode(),
11510 }
11511 }
11512 }
11513 impl CstDecode<crate::model::RefundableSwap> for wire_cst_refundable_swap {
11514 fn cst_decode(self) -> crate::model::RefundableSwap {
11516 crate::model::RefundableSwap {
11517 swap_address: self.swap_address.cst_decode(),
11518 timestamp: self.timestamp.cst_decode(),
11519 amount_sat: self.amount_sat.cst_decode(),
11520 last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11521 }
11522 }
11523 }
11524 impl CstDecode<crate::model::RestoreRequest> for wire_cst_restore_request {
11525 fn cst_decode(self) -> crate::model::RestoreRequest {
11527 crate::model::RestoreRequest {
11528 backup_path: self.backup_path.cst_decode(),
11529 }
11530 }
11531 }
11532 impl CstDecode<crate::bindings::RouteHint> for wire_cst_route_hint {
11533 fn cst_decode(self) -> crate::bindings::RouteHint {
11535 crate::bindings::RouteHint {
11536 hops: self.hops.cst_decode(),
11537 }
11538 }
11539 }
11540 impl CstDecode<crate::bindings::RouteHintHop> for wire_cst_route_hint_hop {
11541 fn cst_decode(self) -> crate::bindings::RouteHintHop {
11543 crate::bindings::RouteHintHop {
11544 src_node_id: self.src_node_id.cst_decode(),
11545 short_channel_id: self.short_channel_id.cst_decode(),
11546 fees_base_msat: self.fees_base_msat.cst_decode(),
11547 fees_proportional_millionths: self.fees_proportional_millionths.cst_decode(),
11548 cltv_expiry_delta: self.cltv_expiry_delta.cst_decode(),
11549 htlc_minimum_msat: self.htlc_minimum_msat.cst_decode(),
11550 htlc_maximum_msat: self.htlc_maximum_msat.cst_decode(),
11551 }
11552 }
11553 }
11554 impl CstDecode<crate::error::SdkError> for wire_cst_sdk_error {
11555 fn cst_decode(self) -> crate::error::SdkError {
11557 match self.tag {
11558 0 => crate::error::SdkError::AlreadyStarted,
11559 1 => {
11560 let ans = unsafe { self.kind.Generic };
11561 crate::error::SdkError::Generic {
11562 err: ans.err.cst_decode(),
11563 }
11564 }
11565 2 => crate::error::SdkError::NotStarted,
11566 3 => {
11567 let ans = unsafe { self.kind.ServiceConnectivity };
11568 crate::error::SdkError::ServiceConnectivity {
11569 err: ans.err.cst_decode(),
11570 }
11571 }
11572 _ => unreachable!(),
11573 }
11574 }
11575 }
11576 impl CstDecode<crate::model::SdkEvent> for wire_cst_sdk_event {
11577 fn cst_decode(self) -> crate::model::SdkEvent {
11579 match self.tag {
11580 0 => {
11581 let ans = unsafe { self.kind.PaymentFailed };
11582 crate::model::SdkEvent::PaymentFailed {
11583 details: ans.details.cst_decode(),
11584 }
11585 }
11586 1 => {
11587 let ans = unsafe { self.kind.PaymentPending };
11588 crate::model::SdkEvent::PaymentPending {
11589 details: ans.details.cst_decode(),
11590 }
11591 }
11592 2 => {
11593 let ans = unsafe { self.kind.PaymentRefundable };
11594 crate::model::SdkEvent::PaymentRefundable {
11595 details: ans.details.cst_decode(),
11596 }
11597 }
11598 3 => {
11599 let ans = unsafe { self.kind.PaymentRefunded };
11600 crate::model::SdkEvent::PaymentRefunded {
11601 details: ans.details.cst_decode(),
11602 }
11603 }
11604 4 => {
11605 let ans = unsafe { self.kind.PaymentRefundPending };
11606 crate::model::SdkEvent::PaymentRefundPending {
11607 details: ans.details.cst_decode(),
11608 }
11609 }
11610 5 => {
11611 let ans = unsafe { self.kind.PaymentSucceeded };
11612 crate::model::SdkEvent::PaymentSucceeded {
11613 details: ans.details.cst_decode(),
11614 }
11615 }
11616 6 => {
11617 let ans = unsafe { self.kind.PaymentWaitingConfirmation };
11618 crate::model::SdkEvent::PaymentWaitingConfirmation {
11619 details: ans.details.cst_decode(),
11620 }
11621 }
11622 7 => {
11623 let ans = unsafe { self.kind.PaymentWaitingFeeAcceptance };
11624 crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
11625 details: ans.details.cst_decode(),
11626 }
11627 }
11628 8 => crate::model::SdkEvent::Synced,
11629 9 => {
11630 let ans = unsafe { self.kind.DataSynced };
11631 crate::model::SdkEvent::DataSynced {
11632 did_pull_new_records: ans.did_pull_new_records.cst_decode(),
11633 }
11634 }
11635 _ => unreachable!(),
11636 }
11637 }
11638 }
11639 impl CstDecode<crate::model::SendDestination> for wire_cst_send_destination {
11640 fn cst_decode(self) -> crate::model::SendDestination {
11642 match self.tag {
11643 0 => {
11644 let ans = unsafe { self.kind.LiquidAddress };
11645 crate::model::SendDestination::LiquidAddress {
11646 address_data: ans.address_data.cst_decode(),
11647 bip353_address: ans.bip353_address.cst_decode(),
11648 }
11649 }
11650 1 => {
11651 let ans = unsafe { self.kind.Bolt11 };
11652 crate::model::SendDestination::Bolt11 {
11653 invoice: ans.invoice.cst_decode(),
11654 bip353_address: ans.bip353_address.cst_decode(),
11655 }
11656 }
11657 2 => {
11658 let ans = unsafe { self.kind.Bolt12 };
11659 crate::model::SendDestination::Bolt12 {
11660 offer: ans.offer.cst_decode(),
11661 receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11662 bip353_address: ans.bip353_address.cst_decode(),
11663 payer_note: ans.payer_note.cst_decode(),
11664 }
11665 }
11666 _ => unreachable!(),
11667 }
11668 }
11669 }
11670 impl CstDecode<crate::model::SendPaymentRequest> for wire_cst_send_payment_request {
11671 fn cst_decode(self) -> crate::model::SendPaymentRequest {
11673 crate::model::SendPaymentRequest {
11674 prepare_response: self.prepare_response.cst_decode(),
11675 use_asset_fees: self.use_asset_fees.cst_decode(),
11676 }
11677 }
11678 }
11679 impl CstDecode<crate::model::SendPaymentResponse> for wire_cst_send_payment_response {
11680 fn cst_decode(self) -> crate::model::SendPaymentResponse {
11682 crate::model::SendPaymentResponse {
11683 payment: self.payment.cst_decode(),
11684 }
11685 }
11686 }
11687 impl CstDecode<crate::model::SignMessageRequest> for wire_cst_sign_message_request {
11688 fn cst_decode(self) -> crate::model::SignMessageRequest {
11690 crate::model::SignMessageRequest {
11691 message: self.message.cst_decode(),
11692 }
11693 }
11694 }
11695 impl CstDecode<crate::model::SignMessageResponse> for wire_cst_sign_message_response {
11696 fn cst_decode(self) -> crate::model::SignMessageResponse {
11698 crate::model::SignMessageResponse {
11699 signature: self.signature.cst_decode(),
11700 }
11701 }
11702 }
11703 impl CstDecode<crate::bindings::SuccessAction> for wire_cst_success_action {
11704 fn cst_decode(self) -> crate::bindings::SuccessAction {
11706 match self.tag {
11707 0 => {
11708 let ans = unsafe { self.kind.Aes };
11709 crate::bindings::SuccessAction::Aes {
11710 data: ans.data.cst_decode(),
11711 }
11712 }
11713 1 => {
11714 let ans = unsafe { self.kind.Message };
11715 crate::bindings::SuccessAction::Message {
11716 data: ans.data.cst_decode(),
11717 }
11718 }
11719 2 => {
11720 let ans = unsafe { self.kind.Url };
11721 crate::bindings::SuccessAction::Url {
11722 data: ans.data.cst_decode(),
11723 }
11724 }
11725 _ => unreachable!(),
11726 }
11727 }
11728 }
11729 impl CstDecode<crate::bindings::SuccessActionProcessed> for wire_cst_success_action_processed {
11730 fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
11732 match self.tag {
11733 0 => {
11734 let ans = unsafe { self.kind.Aes };
11735 crate::bindings::SuccessActionProcessed::Aes {
11736 result: ans.result.cst_decode(),
11737 }
11738 }
11739 1 => {
11740 let ans = unsafe { self.kind.Message };
11741 crate::bindings::SuccessActionProcessed::Message {
11742 data: ans.data.cst_decode(),
11743 }
11744 }
11745 2 => {
11746 let ans = unsafe { self.kind.Url };
11747 crate::bindings::SuccessActionProcessed::Url {
11748 data: ans.data.cst_decode(),
11749 }
11750 }
11751 _ => unreachable!(),
11752 }
11753 }
11754 }
11755 impl CstDecode<crate::bindings::Symbol> for wire_cst_symbol {
11756 fn cst_decode(self) -> crate::bindings::Symbol {
11758 crate::bindings::Symbol {
11759 grapheme: self.grapheme.cst_decode(),
11760 template: self.template.cst_decode(),
11761 rtl: self.rtl.cst_decode(),
11762 position: self.position.cst_decode(),
11763 }
11764 }
11765 }
11766 impl CstDecode<crate::bindings::UrlSuccessActionData> for wire_cst_url_success_action_data {
11767 fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
11769 crate::bindings::UrlSuccessActionData {
11770 description: self.description.cst_decode(),
11771 url: self.url.cst_decode(),
11772 matches_callback_domain: self.matches_callback_domain.cst_decode(),
11773 }
11774 }
11775 }
11776 impl CstDecode<crate::model::WalletInfo> for wire_cst_wallet_info {
11777 fn cst_decode(self) -> crate::model::WalletInfo {
11779 crate::model::WalletInfo {
11780 balance_sat: self.balance_sat.cst_decode(),
11781 pending_send_sat: self.pending_send_sat.cst_decode(),
11782 pending_receive_sat: self.pending_receive_sat.cst_decode(),
11783 fingerprint: self.fingerprint.cst_decode(),
11784 pubkey: self.pubkey.cst_decode(),
11785 asset_balances: self.asset_balances.cst_decode(),
11786 }
11787 }
11788 }
11789 impl NewWithNullPtr for wire_cst_accept_payment_proposed_fees_request {
11790 fn new_with_null_ptr() -> Self {
11791 Self {
11792 response: Default::default(),
11793 }
11794 }
11795 }
11796 impl Default for wire_cst_accept_payment_proposed_fees_request {
11797 fn default() -> Self {
11798 Self::new_with_null_ptr()
11799 }
11800 }
11801 impl NewWithNullPtr for wire_cst_aes_success_action_data {
11802 fn new_with_null_ptr() -> Self {
11803 Self {
11804 description: core::ptr::null_mut(),
11805 ciphertext: core::ptr::null_mut(),
11806 iv: core::ptr::null_mut(),
11807 }
11808 }
11809 }
11810 impl Default for wire_cst_aes_success_action_data {
11811 fn default() -> Self {
11812 Self::new_with_null_ptr()
11813 }
11814 }
11815 impl NewWithNullPtr for wire_cst_aes_success_action_data_decrypted {
11816 fn new_with_null_ptr() -> Self {
11817 Self {
11818 description: core::ptr::null_mut(),
11819 plaintext: core::ptr::null_mut(),
11820 }
11821 }
11822 }
11823 impl Default for wire_cst_aes_success_action_data_decrypted {
11824 fn default() -> Self {
11825 Self::new_with_null_ptr()
11826 }
11827 }
11828 impl NewWithNullPtr for wire_cst_aes_success_action_data_result {
11829 fn new_with_null_ptr() -> Self {
11830 Self {
11831 tag: -1,
11832 kind: AesSuccessActionDataResultKind { nil__: () },
11833 }
11834 }
11835 }
11836 impl Default for wire_cst_aes_success_action_data_result {
11837 fn default() -> Self {
11838 Self::new_with_null_ptr()
11839 }
11840 }
11841 impl NewWithNullPtr for wire_cst_amount {
11842 fn new_with_null_ptr() -> Self {
11843 Self {
11844 tag: -1,
11845 kind: AmountKind { nil__: () },
11846 }
11847 }
11848 }
11849 impl Default for wire_cst_amount {
11850 fn default() -> Self {
11851 Self::new_with_null_ptr()
11852 }
11853 }
11854 impl NewWithNullPtr for wire_cst_asset_balance {
11855 fn new_with_null_ptr() -> Self {
11856 Self {
11857 asset_id: core::ptr::null_mut(),
11858 balance_sat: Default::default(),
11859 name: core::ptr::null_mut(),
11860 ticker: core::ptr::null_mut(),
11861 balance: core::ptr::null_mut(),
11862 }
11863 }
11864 }
11865 impl Default for wire_cst_asset_balance {
11866 fn default() -> Self {
11867 Self::new_with_null_ptr()
11868 }
11869 }
11870 impl NewWithNullPtr for wire_cst_asset_info {
11871 fn new_with_null_ptr() -> Self {
11872 Self {
11873 name: core::ptr::null_mut(),
11874 ticker: core::ptr::null_mut(),
11875 amount: Default::default(),
11876 fees: core::ptr::null_mut(),
11877 }
11878 }
11879 }
11880 impl Default for wire_cst_asset_info {
11881 fn default() -> Self {
11882 Self::new_with_null_ptr()
11883 }
11884 }
11885 impl NewWithNullPtr for wire_cst_asset_metadata {
11886 fn new_with_null_ptr() -> Self {
11887 Self {
11888 asset_id: core::ptr::null_mut(),
11889 name: core::ptr::null_mut(),
11890 ticker: core::ptr::null_mut(),
11891 precision: Default::default(),
11892 fiat_id: core::ptr::null_mut(),
11893 }
11894 }
11895 }
11896 impl Default for wire_cst_asset_metadata {
11897 fn default() -> Self {
11898 Self::new_with_null_ptr()
11899 }
11900 }
11901 impl NewWithNullPtr for wire_cst_backup_request {
11902 fn new_with_null_ptr() -> Self {
11903 Self {
11904 backup_path: core::ptr::null_mut(),
11905 }
11906 }
11907 }
11908 impl Default for wire_cst_backup_request {
11909 fn default() -> Self {
11910 Self::new_with_null_ptr()
11911 }
11912 }
11913 impl NewWithNullPtr for wire_cst_binding_event_listener {
11914 fn new_with_null_ptr() -> Self {
11915 Self {
11916 stream: core::ptr::null_mut(),
11917 }
11918 }
11919 }
11920 impl Default for wire_cst_binding_event_listener {
11921 fn default() -> Self {
11922 Self::new_with_null_ptr()
11923 }
11924 }
11925 impl NewWithNullPtr for wire_cst_bitcoin_address_data {
11926 fn new_with_null_ptr() -> Self {
11927 Self {
11928 address: core::ptr::null_mut(),
11929 network: Default::default(),
11930 amount_sat: core::ptr::null_mut(),
11931 label: core::ptr::null_mut(),
11932 message: core::ptr::null_mut(),
11933 }
11934 }
11935 }
11936 impl Default for wire_cst_bitcoin_address_data {
11937 fn default() -> Self {
11938 Self::new_with_null_ptr()
11939 }
11940 }
11941 impl NewWithNullPtr for wire_cst_blockchain_explorer {
11942 fn new_with_null_ptr() -> Self {
11943 Self {
11944 tag: -1,
11945 kind: BlockchainExplorerKind { nil__: () },
11946 }
11947 }
11948 }
11949 impl Default for wire_cst_blockchain_explorer {
11950 fn default() -> Self {
11951 Self::new_with_null_ptr()
11952 }
11953 }
11954 impl NewWithNullPtr for wire_cst_blockchain_info {
11955 fn new_with_null_ptr() -> Self {
11956 Self {
11957 liquid_tip: Default::default(),
11958 bitcoin_tip: Default::default(),
11959 }
11960 }
11961 }
11962 impl Default for wire_cst_blockchain_info {
11963 fn default() -> Self {
11964 Self::new_with_null_ptr()
11965 }
11966 }
11967 impl NewWithNullPtr for wire_cst_buy_bitcoin_request {
11968 fn new_with_null_ptr() -> Self {
11969 Self {
11970 prepare_response: Default::default(),
11971 redirect_url: core::ptr::null_mut(),
11972 }
11973 }
11974 }
11975 impl Default for wire_cst_buy_bitcoin_request {
11976 fn default() -> Self {
11977 Self::new_with_null_ptr()
11978 }
11979 }
11980 impl NewWithNullPtr for wire_cst_check_message_request {
11981 fn new_with_null_ptr() -> Self {
11982 Self {
11983 message: core::ptr::null_mut(),
11984 pubkey: core::ptr::null_mut(),
11985 signature: core::ptr::null_mut(),
11986 }
11987 }
11988 }
11989 impl Default for wire_cst_check_message_request {
11990 fn default() -> Self {
11991 Self::new_with_null_ptr()
11992 }
11993 }
11994 impl NewWithNullPtr for wire_cst_check_message_response {
11995 fn new_with_null_ptr() -> Self {
11996 Self {
11997 is_valid: Default::default(),
11998 }
11999 }
12000 }
12001 impl Default for wire_cst_check_message_response {
12002 fn default() -> Self {
12003 Self::new_with_null_ptr()
12004 }
12005 }
12006 impl NewWithNullPtr for wire_cst_config {
12007 fn new_with_null_ptr() -> Self {
12008 Self {
12009 liquid_explorer: Default::default(),
12010 bitcoin_explorer: Default::default(),
12011 working_dir: core::ptr::null_mut(),
12012 network: Default::default(),
12013 payment_timeout_sec: Default::default(),
12014 sync_service_url: core::ptr::null_mut(),
12015 zero_conf_max_amount_sat: core::ptr::null_mut(),
12016 breez_api_key: core::ptr::null_mut(),
12017 external_input_parsers: core::ptr::null_mut(),
12018 use_default_external_input_parsers: Default::default(),
12019 onchain_fee_rate_leeway_sat_per_vbyte: core::ptr::null_mut(),
12020 asset_metadata: core::ptr::null_mut(),
12021 sideswap_api_key: core::ptr::null_mut(),
12022 }
12023 }
12024 }
12025 impl Default for wire_cst_config {
12026 fn default() -> Self {
12027 Self::new_with_null_ptr()
12028 }
12029 }
12030 impl NewWithNullPtr for wire_cst_connect_request {
12031 fn new_with_null_ptr() -> Self {
12032 Self {
12033 config: Default::default(),
12034 mnemonic: core::ptr::null_mut(),
12035 passphrase: core::ptr::null_mut(),
12036 seed: core::ptr::null_mut(),
12037 }
12038 }
12039 }
12040 impl Default for wire_cst_connect_request {
12041 fn default() -> Self {
12042 Self::new_with_null_ptr()
12043 }
12044 }
12045 impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_request {
12046 fn new_with_null_ptr() -> Self {
12047 Self {
12048 offer: core::ptr::null_mut(),
12049 invoice_request: core::ptr::null_mut(),
12050 }
12051 }
12052 }
12053 impl Default for wire_cst_create_bolt_12_invoice_request {
12054 fn default() -> Self {
12055 Self::new_with_null_ptr()
12056 }
12057 }
12058 impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_response {
12059 fn new_with_null_ptr() -> Self {
12060 Self {
12061 invoice: core::ptr::null_mut(),
12062 }
12063 }
12064 }
12065 impl Default for wire_cst_create_bolt_12_invoice_response {
12066 fn default() -> Self {
12067 Self::new_with_null_ptr()
12068 }
12069 }
12070 impl NewWithNullPtr for wire_cst_currency_info {
12071 fn new_with_null_ptr() -> Self {
12072 Self {
12073 name: core::ptr::null_mut(),
12074 fraction_size: Default::default(),
12075 spacing: core::ptr::null_mut(),
12076 symbol: core::ptr::null_mut(),
12077 uniq_symbol: core::ptr::null_mut(),
12078 localized_name: core::ptr::null_mut(),
12079 locale_overrides: core::ptr::null_mut(),
12080 }
12081 }
12082 }
12083 impl Default for wire_cst_currency_info {
12084 fn default() -> Self {
12085 Self::new_with_null_ptr()
12086 }
12087 }
12088 impl NewWithNullPtr for wire_cst_external_input_parser {
12089 fn new_with_null_ptr() -> Self {
12090 Self {
12091 provider_id: core::ptr::null_mut(),
12092 input_regex: core::ptr::null_mut(),
12093 parser_url: core::ptr::null_mut(),
12094 }
12095 }
12096 }
12097 impl Default for wire_cst_external_input_parser {
12098 fn default() -> Self {
12099 Self::new_with_null_ptr()
12100 }
12101 }
12102 impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_request {
12103 fn new_with_null_ptr() -> Self {
12104 Self {
12105 swap_id: core::ptr::null_mut(),
12106 }
12107 }
12108 }
12109 impl Default for wire_cst_fetch_payment_proposed_fees_request {
12110 fn default() -> Self {
12111 Self::new_with_null_ptr()
12112 }
12113 }
12114 impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_response {
12115 fn new_with_null_ptr() -> Self {
12116 Self {
12117 swap_id: core::ptr::null_mut(),
12118 fees_sat: Default::default(),
12119 payer_amount_sat: Default::default(),
12120 receiver_amount_sat: Default::default(),
12121 }
12122 }
12123 }
12124 impl Default for wire_cst_fetch_payment_proposed_fees_response {
12125 fn default() -> Self {
12126 Self::new_with_null_ptr()
12127 }
12128 }
12129 impl NewWithNullPtr for wire_cst_fiat_currency {
12130 fn new_with_null_ptr() -> Self {
12131 Self {
12132 id: core::ptr::null_mut(),
12133 info: Default::default(),
12134 }
12135 }
12136 }
12137 impl Default for wire_cst_fiat_currency {
12138 fn default() -> Self {
12139 Self::new_with_null_ptr()
12140 }
12141 }
12142 impl NewWithNullPtr for wire_cst_get_info_response {
12143 fn new_with_null_ptr() -> Self {
12144 Self {
12145 wallet_info: Default::default(),
12146 blockchain_info: Default::default(),
12147 }
12148 }
12149 }
12150 impl Default for wire_cst_get_info_response {
12151 fn default() -> Self {
12152 Self::new_with_null_ptr()
12153 }
12154 }
12155 impl NewWithNullPtr for wire_cst_get_payment_request {
12156 fn new_with_null_ptr() -> Self {
12157 Self {
12158 tag: -1,
12159 kind: GetPaymentRequestKind { nil__: () },
12160 }
12161 }
12162 }
12163 impl Default for wire_cst_get_payment_request {
12164 fn default() -> Self {
12165 Self::new_with_null_ptr()
12166 }
12167 }
12168 impl NewWithNullPtr for wire_cst_input_type {
12169 fn new_with_null_ptr() -> Self {
12170 Self {
12171 tag: -1,
12172 kind: InputTypeKind { nil__: () },
12173 }
12174 }
12175 }
12176 impl Default for wire_cst_input_type {
12177 fn default() -> Self {
12178 Self::new_with_null_ptr()
12179 }
12180 }
12181 impl NewWithNullPtr for wire_cst_lightning_payment_limits_response {
12182 fn new_with_null_ptr() -> Self {
12183 Self {
12184 send: Default::default(),
12185 receive: Default::default(),
12186 }
12187 }
12188 }
12189 impl Default for wire_cst_lightning_payment_limits_response {
12190 fn default() -> Self {
12191 Self::new_with_null_ptr()
12192 }
12193 }
12194 impl NewWithNullPtr for wire_cst_limits {
12195 fn new_with_null_ptr() -> Self {
12196 Self {
12197 min_sat: Default::default(),
12198 max_sat: Default::default(),
12199 max_zero_conf_sat: Default::default(),
12200 }
12201 }
12202 }
12203 impl Default for wire_cst_limits {
12204 fn default() -> Self {
12205 Self::new_with_null_ptr()
12206 }
12207 }
12208 impl NewWithNullPtr for wire_cst_liquid_address_data {
12209 fn new_with_null_ptr() -> Self {
12210 Self {
12211 address: core::ptr::null_mut(),
12212 network: Default::default(),
12213 asset_id: core::ptr::null_mut(),
12214 amount: core::ptr::null_mut(),
12215 amount_sat: core::ptr::null_mut(),
12216 label: core::ptr::null_mut(),
12217 message: core::ptr::null_mut(),
12218 }
12219 }
12220 }
12221 impl Default for wire_cst_liquid_address_data {
12222 fn default() -> Self {
12223 Self::new_with_null_ptr()
12224 }
12225 }
12226 impl NewWithNullPtr for wire_cst_list_payment_details {
12227 fn new_with_null_ptr() -> Self {
12228 Self {
12229 tag: -1,
12230 kind: ListPaymentDetailsKind { nil__: () },
12231 }
12232 }
12233 }
12234 impl Default for wire_cst_list_payment_details {
12235 fn default() -> Self {
12236 Self::new_with_null_ptr()
12237 }
12238 }
12239 impl NewWithNullPtr for wire_cst_list_payments_request {
12240 fn new_with_null_ptr() -> Self {
12241 Self {
12242 filters: core::ptr::null_mut(),
12243 states: core::ptr::null_mut(),
12244 from_timestamp: core::ptr::null_mut(),
12245 to_timestamp: core::ptr::null_mut(),
12246 offset: core::ptr::null_mut(),
12247 limit: core::ptr::null_mut(),
12248 details: core::ptr::null_mut(),
12249 sort_ascending: core::ptr::null_mut(),
12250 }
12251 }
12252 }
12253 impl Default for wire_cst_list_payments_request {
12254 fn default() -> Self {
12255 Self::new_with_null_ptr()
12256 }
12257 }
12258 impl NewWithNullPtr for wire_cst_ln_invoice {
12259 fn new_with_null_ptr() -> Self {
12260 Self {
12261 bolt11: core::ptr::null_mut(),
12262 network: Default::default(),
12263 payee_pubkey: core::ptr::null_mut(),
12264 payment_hash: core::ptr::null_mut(),
12265 description: core::ptr::null_mut(),
12266 description_hash: core::ptr::null_mut(),
12267 amount_msat: core::ptr::null_mut(),
12268 timestamp: Default::default(),
12269 expiry: Default::default(),
12270 routing_hints: core::ptr::null_mut(),
12271 payment_secret: core::ptr::null_mut(),
12272 min_final_cltv_expiry_delta: Default::default(),
12273 }
12274 }
12275 }
12276 impl Default for wire_cst_ln_invoice {
12277 fn default() -> Self {
12278 Self::new_with_null_ptr()
12279 }
12280 }
12281 impl NewWithNullPtr for wire_cst_ln_offer {
12282 fn new_with_null_ptr() -> Self {
12283 Self {
12284 offer: core::ptr::null_mut(),
12285 chains: core::ptr::null_mut(),
12286 min_amount: core::ptr::null_mut(),
12287 description: core::ptr::null_mut(),
12288 absolute_expiry: core::ptr::null_mut(),
12289 issuer: core::ptr::null_mut(),
12290 signing_pubkey: core::ptr::null_mut(),
12291 paths: core::ptr::null_mut(),
12292 }
12293 }
12294 }
12295 impl Default for wire_cst_ln_offer {
12296 fn default() -> Self {
12297 Self::new_with_null_ptr()
12298 }
12299 }
12300 impl NewWithNullPtr for wire_cst_ln_offer_blinded_path {
12301 fn new_with_null_ptr() -> Self {
12302 Self {
12303 blinded_hops: core::ptr::null_mut(),
12304 }
12305 }
12306 }
12307 impl Default for wire_cst_ln_offer_blinded_path {
12308 fn default() -> Self {
12309 Self::new_with_null_ptr()
12310 }
12311 }
12312 impl NewWithNullPtr for wire_cst_ln_url_auth_error {
12313 fn new_with_null_ptr() -> Self {
12314 Self {
12315 tag: -1,
12316 kind: LnUrlAuthErrorKind { nil__: () },
12317 }
12318 }
12319 }
12320 impl Default for wire_cst_ln_url_auth_error {
12321 fn default() -> Self {
12322 Self::new_with_null_ptr()
12323 }
12324 }
12325 impl NewWithNullPtr for wire_cst_ln_url_auth_request_data {
12326 fn new_with_null_ptr() -> Self {
12327 Self {
12328 k1: core::ptr::null_mut(),
12329 action: core::ptr::null_mut(),
12330 domain: core::ptr::null_mut(),
12331 url: core::ptr::null_mut(),
12332 }
12333 }
12334 }
12335 impl Default for wire_cst_ln_url_auth_request_data {
12336 fn default() -> Self {
12337 Self::new_with_null_ptr()
12338 }
12339 }
12340 impl NewWithNullPtr for wire_cst_ln_url_callback_status {
12341 fn new_with_null_ptr() -> Self {
12342 Self {
12343 tag: -1,
12344 kind: LnUrlCallbackStatusKind { nil__: () },
12345 }
12346 }
12347 }
12348 impl Default for wire_cst_ln_url_callback_status {
12349 fn default() -> Self {
12350 Self::new_with_null_ptr()
12351 }
12352 }
12353 impl NewWithNullPtr for wire_cst_ln_url_error_data {
12354 fn new_with_null_ptr() -> Self {
12355 Self {
12356 reason: core::ptr::null_mut(),
12357 }
12358 }
12359 }
12360 impl Default for wire_cst_ln_url_error_data {
12361 fn default() -> Self {
12362 Self::new_with_null_ptr()
12363 }
12364 }
12365 impl NewWithNullPtr for wire_cst_ln_url_info {
12366 fn new_with_null_ptr() -> Self {
12367 Self {
12368 ln_address: core::ptr::null_mut(),
12369 lnurl_pay_comment: core::ptr::null_mut(),
12370 lnurl_pay_domain: core::ptr::null_mut(),
12371 lnurl_pay_metadata: core::ptr::null_mut(),
12372 lnurl_pay_success_action: core::ptr::null_mut(),
12373 lnurl_pay_unprocessed_success_action: core::ptr::null_mut(),
12374 lnurl_withdraw_endpoint: core::ptr::null_mut(),
12375 }
12376 }
12377 }
12378 impl Default for wire_cst_ln_url_info {
12379 fn default() -> Self {
12380 Self::new_with_null_ptr()
12381 }
12382 }
12383 impl NewWithNullPtr for wire_cst_ln_url_pay_error {
12384 fn new_with_null_ptr() -> Self {
12385 Self {
12386 tag: -1,
12387 kind: LnUrlPayErrorKind { nil__: () },
12388 }
12389 }
12390 }
12391 impl Default for wire_cst_ln_url_pay_error {
12392 fn default() -> Self {
12393 Self::new_with_null_ptr()
12394 }
12395 }
12396 impl NewWithNullPtr for wire_cst_ln_url_pay_error_data {
12397 fn new_with_null_ptr() -> Self {
12398 Self {
12399 payment_hash: core::ptr::null_mut(),
12400 reason: core::ptr::null_mut(),
12401 }
12402 }
12403 }
12404 impl Default for wire_cst_ln_url_pay_error_data {
12405 fn default() -> Self {
12406 Self::new_with_null_ptr()
12407 }
12408 }
12409 impl NewWithNullPtr for wire_cst_ln_url_pay_request {
12410 fn new_with_null_ptr() -> Self {
12411 Self {
12412 prepare_response: Default::default(),
12413 }
12414 }
12415 }
12416 impl Default for wire_cst_ln_url_pay_request {
12417 fn default() -> Self {
12418 Self::new_with_null_ptr()
12419 }
12420 }
12421 impl NewWithNullPtr for wire_cst_ln_url_pay_request_data {
12422 fn new_with_null_ptr() -> Self {
12423 Self {
12424 callback: core::ptr::null_mut(),
12425 min_sendable: Default::default(),
12426 max_sendable: Default::default(),
12427 metadata_str: core::ptr::null_mut(),
12428 comment_allowed: Default::default(),
12429 domain: core::ptr::null_mut(),
12430 allows_nostr: Default::default(),
12431 nostr_pubkey: core::ptr::null_mut(),
12432 ln_address: core::ptr::null_mut(),
12433 }
12434 }
12435 }
12436 impl Default for wire_cst_ln_url_pay_request_data {
12437 fn default() -> Self {
12438 Self::new_with_null_ptr()
12439 }
12440 }
12441 impl NewWithNullPtr for wire_cst_ln_url_pay_result {
12442 fn new_with_null_ptr() -> Self {
12443 Self {
12444 tag: -1,
12445 kind: LnUrlPayResultKind { nil__: () },
12446 }
12447 }
12448 }
12449 impl Default for wire_cst_ln_url_pay_result {
12450 fn default() -> Self {
12451 Self::new_with_null_ptr()
12452 }
12453 }
12454 impl NewWithNullPtr for wire_cst_ln_url_pay_success_data {
12455 fn new_with_null_ptr() -> Self {
12456 Self {
12457 payment: Default::default(),
12458 success_action: core::ptr::null_mut(),
12459 }
12460 }
12461 }
12462 impl Default for wire_cst_ln_url_pay_success_data {
12463 fn default() -> Self {
12464 Self::new_with_null_ptr()
12465 }
12466 }
12467 impl NewWithNullPtr for wire_cst_ln_url_withdraw_error {
12468 fn new_with_null_ptr() -> Self {
12469 Self {
12470 tag: -1,
12471 kind: LnUrlWithdrawErrorKind { nil__: () },
12472 }
12473 }
12474 }
12475 impl Default for wire_cst_ln_url_withdraw_error {
12476 fn default() -> Self {
12477 Self::new_with_null_ptr()
12478 }
12479 }
12480 impl NewWithNullPtr for wire_cst_ln_url_withdraw_request {
12481 fn new_with_null_ptr() -> Self {
12482 Self {
12483 data: Default::default(),
12484 amount_msat: Default::default(),
12485 description: core::ptr::null_mut(),
12486 }
12487 }
12488 }
12489 impl Default for wire_cst_ln_url_withdraw_request {
12490 fn default() -> Self {
12491 Self::new_with_null_ptr()
12492 }
12493 }
12494 impl NewWithNullPtr for wire_cst_ln_url_withdraw_request_data {
12495 fn new_with_null_ptr() -> Self {
12496 Self {
12497 callback: core::ptr::null_mut(),
12498 k1: core::ptr::null_mut(),
12499 default_description: core::ptr::null_mut(),
12500 min_withdrawable: Default::default(),
12501 max_withdrawable: Default::default(),
12502 }
12503 }
12504 }
12505 impl Default for wire_cst_ln_url_withdraw_request_data {
12506 fn default() -> Self {
12507 Self::new_with_null_ptr()
12508 }
12509 }
12510 impl NewWithNullPtr for wire_cst_ln_url_withdraw_result {
12511 fn new_with_null_ptr() -> Self {
12512 Self {
12513 tag: -1,
12514 kind: LnUrlWithdrawResultKind { nil__: () },
12515 }
12516 }
12517 }
12518 impl Default for wire_cst_ln_url_withdraw_result {
12519 fn default() -> Self {
12520 Self::new_with_null_ptr()
12521 }
12522 }
12523 impl NewWithNullPtr for wire_cst_ln_url_withdraw_success_data {
12524 fn new_with_null_ptr() -> Self {
12525 Self {
12526 invoice: Default::default(),
12527 }
12528 }
12529 }
12530 impl Default for wire_cst_ln_url_withdraw_success_data {
12531 fn default() -> Self {
12532 Self::new_with_null_ptr()
12533 }
12534 }
12535 impl NewWithNullPtr for wire_cst_locale_overrides {
12536 fn new_with_null_ptr() -> Self {
12537 Self {
12538 locale: core::ptr::null_mut(),
12539 spacing: core::ptr::null_mut(),
12540 symbol: Default::default(),
12541 }
12542 }
12543 }
12544 impl Default for wire_cst_locale_overrides {
12545 fn default() -> Self {
12546 Self::new_with_null_ptr()
12547 }
12548 }
12549 impl NewWithNullPtr for wire_cst_localized_name {
12550 fn new_with_null_ptr() -> Self {
12551 Self {
12552 locale: core::ptr::null_mut(),
12553 name: core::ptr::null_mut(),
12554 }
12555 }
12556 }
12557 impl Default for wire_cst_localized_name {
12558 fn default() -> Self {
12559 Self::new_with_null_ptr()
12560 }
12561 }
12562 impl NewWithNullPtr for wire_cst_log_entry {
12563 fn new_with_null_ptr() -> Self {
12564 Self {
12565 line: core::ptr::null_mut(),
12566 level: core::ptr::null_mut(),
12567 }
12568 }
12569 }
12570 impl Default for wire_cst_log_entry {
12571 fn default() -> Self {
12572 Self::new_with_null_ptr()
12573 }
12574 }
12575 impl NewWithNullPtr for wire_cst_message_success_action_data {
12576 fn new_with_null_ptr() -> Self {
12577 Self {
12578 message: core::ptr::null_mut(),
12579 }
12580 }
12581 }
12582 impl Default for wire_cst_message_success_action_data {
12583 fn default() -> Self {
12584 Self::new_with_null_ptr()
12585 }
12586 }
12587 impl NewWithNullPtr for wire_cst_onchain_payment_limits_response {
12588 fn new_with_null_ptr() -> Self {
12589 Self {
12590 send: Default::default(),
12591 receive: Default::default(),
12592 }
12593 }
12594 }
12595 impl Default for wire_cst_onchain_payment_limits_response {
12596 fn default() -> Self {
12597 Self::new_with_null_ptr()
12598 }
12599 }
12600 impl NewWithNullPtr for wire_cst_pay_amount {
12601 fn new_with_null_ptr() -> Self {
12602 Self {
12603 tag: -1,
12604 kind: PayAmountKind { nil__: () },
12605 }
12606 }
12607 }
12608 impl Default for wire_cst_pay_amount {
12609 fn default() -> Self {
12610 Self::new_with_null_ptr()
12611 }
12612 }
12613 impl NewWithNullPtr for wire_cst_pay_onchain_request {
12614 fn new_with_null_ptr() -> Self {
12615 Self {
12616 address: core::ptr::null_mut(),
12617 prepare_response: Default::default(),
12618 }
12619 }
12620 }
12621 impl Default for wire_cst_pay_onchain_request {
12622 fn default() -> Self {
12623 Self::new_with_null_ptr()
12624 }
12625 }
12626 impl NewWithNullPtr for wire_cst_payment {
12627 fn new_with_null_ptr() -> Self {
12628 Self {
12629 destination: core::ptr::null_mut(),
12630 tx_id: core::ptr::null_mut(),
12631 unblinding_data: core::ptr::null_mut(),
12632 timestamp: Default::default(),
12633 amount_sat: Default::default(),
12634 fees_sat: Default::default(),
12635 swapper_fees_sat: core::ptr::null_mut(),
12636 payment_type: Default::default(),
12637 status: Default::default(),
12638 details: Default::default(),
12639 }
12640 }
12641 }
12642 impl Default for wire_cst_payment {
12643 fn default() -> Self {
12644 Self::new_with_null_ptr()
12645 }
12646 }
12647 impl NewWithNullPtr for wire_cst_payment_details {
12648 fn new_with_null_ptr() -> Self {
12649 Self {
12650 tag: -1,
12651 kind: PaymentDetailsKind { nil__: () },
12652 }
12653 }
12654 }
12655 impl Default for wire_cst_payment_details {
12656 fn default() -> Self {
12657 Self::new_with_null_ptr()
12658 }
12659 }
12660 impl NewWithNullPtr for wire_cst_payment_error {
12661 fn new_with_null_ptr() -> Self {
12662 Self {
12663 tag: -1,
12664 kind: PaymentErrorKind { nil__: () },
12665 }
12666 }
12667 }
12668 impl Default for wire_cst_payment_error {
12669 fn default() -> Self {
12670 Self::new_with_null_ptr()
12671 }
12672 }
12673 impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_request {
12674 fn new_with_null_ptr() -> Self {
12675 Self {
12676 provider: Default::default(),
12677 amount_sat: Default::default(),
12678 }
12679 }
12680 }
12681 impl Default for wire_cst_prepare_buy_bitcoin_request {
12682 fn default() -> Self {
12683 Self::new_with_null_ptr()
12684 }
12685 }
12686 impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_response {
12687 fn new_with_null_ptr() -> Self {
12688 Self {
12689 provider: Default::default(),
12690 amount_sat: Default::default(),
12691 fees_sat: Default::default(),
12692 }
12693 }
12694 }
12695 impl Default for wire_cst_prepare_buy_bitcoin_response {
12696 fn default() -> Self {
12697 Self::new_with_null_ptr()
12698 }
12699 }
12700 impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_request {
12701 fn new_with_null_ptr() -> Self {
12702 Self {
12703 data: Default::default(),
12704 amount: Default::default(),
12705 bip353_address: core::ptr::null_mut(),
12706 comment: core::ptr::null_mut(),
12707 validate_success_action_url: core::ptr::null_mut(),
12708 }
12709 }
12710 }
12711 impl Default for wire_cst_prepare_ln_url_pay_request {
12712 fn default() -> Self {
12713 Self::new_with_null_ptr()
12714 }
12715 }
12716 impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_response {
12717 fn new_with_null_ptr() -> Self {
12718 Self {
12719 destination: Default::default(),
12720 fees_sat: Default::default(),
12721 data: Default::default(),
12722 amount: Default::default(),
12723 comment: core::ptr::null_mut(),
12724 success_action: core::ptr::null_mut(),
12725 }
12726 }
12727 }
12728 impl Default for wire_cst_prepare_ln_url_pay_response {
12729 fn default() -> Self {
12730 Self::new_with_null_ptr()
12731 }
12732 }
12733 impl NewWithNullPtr for wire_cst_prepare_pay_onchain_request {
12734 fn new_with_null_ptr() -> Self {
12735 Self {
12736 amount: Default::default(),
12737 fee_rate_sat_per_vbyte: core::ptr::null_mut(),
12738 }
12739 }
12740 }
12741 impl Default for wire_cst_prepare_pay_onchain_request {
12742 fn default() -> Self {
12743 Self::new_with_null_ptr()
12744 }
12745 }
12746 impl NewWithNullPtr for wire_cst_prepare_pay_onchain_response {
12747 fn new_with_null_ptr() -> Self {
12748 Self {
12749 receiver_amount_sat: Default::default(),
12750 claim_fees_sat: Default::default(),
12751 total_fees_sat: Default::default(),
12752 }
12753 }
12754 }
12755 impl Default for wire_cst_prepare_pay_onchain_response {
12756 fn default() -> Self {
12757 Self::new_with_null_ptr()
12758 }
12759 }
12760 impl NewWithNullPtr for wire_cst_prepare_receive_request {
12761 fn new_with_null_ptr() -> Self {
12762 Self {
12763 payment_method: Default::default(),
12764 amount: core::ptr::null_mut(),
12765 }
12766 }
12767 }
12768 impl Default for wire_cst_prepare_receive_request {
12769 fn default() -> Self {
12770 Self::new_with_null_ptr()
12771 }
12772 }
12773 impl NewWithNullPtr for wire_cst_prepare_receive_response {
12774 fn new_with_null_ptr() -> Self {
12775 Self {
12776 payment_method: Default::default(),
12777 fees_sat: Default::default(),
12778 amount: core::ptr::null_mut(),
12779 min_payer_amount_sat: core::ptr::null_mut(),
12780 max_payer_amount_sat: core::ptr::null_mut(),
12781 swapper_feerate: core::ptr::null_mut(),
12782 }
12783 }
12784 }
12785 impl Default for wire_cst_prepare_receive_response {
12786 fn default() -> Self {
12787 Self::new_with_null_ptr()
12788 }
12789 }
12790 impl NewWithNullPtr for wire_cst_prepare_refund_request {
12791 fn new_with_null_ptr() -> Self {
12792 Self {
12793 swap_address: core::ptr::null_mut(),
12794 refund_address: core::ptr::null_mut(),
12795 fee_rate_sat_per_vbyte: Default::default(),
12796 }
12797 }
12798 }
12799 impl Default for wire_cst_prepare_refund_request {
12800 fn default() -> Self {
12801 Self::new_with_null_ptr()
12802 }
12803 }
12804 impl NewWithNullPtr for wire_cst_prepare_refund_response {
12805 fn new_with_null_ptr() -> Self {
12806 Self {
12807 tx_vsize: Default::default(),
12808 tx_fee_sat: Default::default(),
12809 last_refund_tx_id: core::ptr::null_mut(),
12810 }
12811 }
12812 }
12813 impl Default for wire_cst_prepare_refund_response {
12814 fn default() -> Self {
12815 Self::new_with_null_ptr()
12816 }
12817 }
12818 impl NewWithNullPtr for wire_cst_prepare_send_request {
12819 fn new_with_null_ptr() -> Self {
12820 Self {
12821 destination: core::ptr::null_mut(),
12822 amount: core::ptr::null_mut(),
12823 comment: core::ptr::null_mut(),
12824 }
12825 }
12826 }
12827 impl Default for wire_cst_prepare_send_request {
12828 fn default() -> Self {
12829 Self::new_with_null_ptr()
12830 }
12831 }
12832 impl NewWithNullPtr for wire_cst_prepare_send_response {
12833 fn new_with_null_ptr() -> Self {
12834 Self {
12835 destination: Default::default(),
12836 amount: core::ptr::null_mut(),
12837 fees_sat: core::ptr::null_mut(),
12838 estimated_asset_fees: core::ptr::null_mut(),
12839 }
12840 }
12841 }
12842 impl Default for wire_cst_prepare_send_response {
12843 fn default() -> Self {
12844 Self::new_with_null_ptr()
12845 }
12846 }
12847 impl NewWithNullPtr for wire_cst_rate {
12848 fn new_with_null_ptr() -> Self {
12849 Self {
12850 coin: core::ptr::null_mut(),
12851 value: Default::default(),
12852 }
12853 }
12854 }
12855 impl Default for wire_cst_rate {
12856 fn default() -> Self {
12857 Self::new_with_null_ptr()
12858 }
12859 }
12860 impl NewWithNullPtr for wire_cst_receive_amount {
12861 fn new_with_null_ptr() -> Self {
12862 Self {
12863 tag: -1,
12864 kind: ReceiveAmountKind { nil__: () },
12865 }
12866 }
12867 }
12868 impl Default for wire_cst_receive_amount {
12869 fn default() -> Self {
12870 Self::new_with_null_ptr()
12871 }
12872 }
12873 impl NewWithNullPtr for wire_cst_receive_payment_request {
12874 fn new_with_null_ptr() -> Self {
12875 Self {
12876 prepare_response: Default::default(),
12877 description: core::ptr::null_mut(),
12878 use_description_hash: core::ptr::null_mut(),
12879 }
12880 }
12881 }
12882 impl Default for wire_cst_receive_payment_request {
12883 fn default() -> Self {
12884 Self::new_with_null_ptr()
12885 }
12886 }
12887 impl NewWithNullPtr for wire_cst_receive_payment_response {
12888 fn new_with_null_ptr() -> Self {
12889 Self {
12890 destination: core::ptr::null_mut(),
12891 }
12892 }
12893 }
12894 impl Default for wire_cst_receive_payment_response {
12895 fn default() -> Self {
12896 Self::new_with_null_ptr()
12897 }
12898 }
12899 impl NewWithNullPtr for wire_cst_recommended_fees {
12900 fn new_with_null_ptr() -> Self {
12901 Self {
12902 fastest_fee: Default::default(),
12903 half_hour_fee: Default::default(),
12904 hour_fee: Default::default(),
12905 economy_fee: Default::default(),
12906 minimum_fee: Default::default(),
12907 }
12908 }
12909 }
12910 impl Default for wire_cst_recommended_fees {
12911 fn default() -> Self {
12912 Self::new_with_null_ptr()
12913 }
12914 }
12915 impl NewWithNullPtr for wire_cst_refund_request {
12916 fn new_with_null_ptr() -> Self {
12917 Self {
12918 swap_address: core::ptr::null_mut(),
12919 refund_address: core::ptr::null_mut(),
12920 fee_rate_sat_per_vbyte: Default::default(),
12921 }
12922 }
12923 }
12924 impl Default for wire_cst_refund_request {
12925 fn default() -> Self {
12926 Self::new_with_null_ptr()
12927 }
12928 }
12929 impl NewWithNullPtr for wire_cst_refund_response {
12930 fn new_with_null_ptr() -> Self {
12931 Self {
12932 refund_tx_id: core::ptr::null_mut(),
12933 }
12934 }
12935 }
12936 impl Default for wire_cst_refund_response {
12937 fn default() -> Self {
12938 Self::new_with_null_ptr()
12939 }
12940 }
12941 impl NewWithNullPtr for wire_cst_refundable_swap {
12942 fn new_with_null_ptr() -> Self {
12943 Self {
12944 swap_address: core::ptr::null_mut(),
12945 timestamp: Default::default(),
12946 amount_sat: Default::default(),
12947 last_refund_tx_id: core::ptr::null_mut(),
12948 }
12949 }
12950 }
12951 impl Default for wire_cst_refundable_swap {
12952 fn default() -> Self {
12953 Self::new_with_null_ptr()
12954 }
12955 }
12956 impl NewWithNullPtr for wire_cst_restore_request {
12957 fn new_with_null_ptr() -> Self {
12958 Self {
12959 backup_path: core::ptr::null_mut(),
12960 }
12961 }
12962 }
12963 impl Default for wire_cst_restore_request {
12964 fn default() -> Self {
12965 Self::new_with_null_ptr()
12966 }
12967 }
12968 impl NewWithNullPtr for wire_cst_route_hint {
12969 fn new_with_null_ptr() -> Self {
12970 Self {
12971 hops: core::ptr::null_mut(),
12972 }
12973 }
12974 }
12975 impl Default for wire_cst_route_hint {
12976 fn default() -> Self {
12977 Self::new_with_null_ptr()
12978 }
12979 }
12980 impl NewWithNullPtr for wire_cst_route_hint_hop {
12981 fn new_with_null_ptr() -> Self {
12982 Self {
12983 src_node_id: core::ptr::null_mut(),
12984 short_channel_id: core::ptr::null_mut(),
12985 fees_base_msat: Default::default(),
12986 fees_proportional_millionths: Default::default(),
12987 cltv_expiry_delta: Default::default(),
12988 htlc_minimum_msat: core::ptr::null_mut(),
12989 htlc_maximum_msat: core::ptr::null_mut(),
12990 }
12991 }
12992 }
12993 impl Default for wire_cst_route_hint_hop {
12994 fn default() -> Self {
12995 Self::new_with_null_ptr()
12996 }
12997 }
12998 impl NewWithNullPtr for wire_cst_sdk_error {
12999 fn new_with_null_ptr() -> Self {
13000 Self {
13001 tag: -1,
13002 kind: SdkErrorKind { nil__: () },
13003 }
13004 }
13005 }
13006 impl Default for wire_cst_sdk_error {
13007 fn default() -> Self {
13008 Self::new_with_null_ptr()
13009 }
13010 }
13011 impl NewWithNullPtr for wire_cst_sdk_event {
13012 fn new_with_null_ptr() -> Self {
13013 Self {
13014 tag: -1,
13015 kind: SdkEventKind { nil__: () },
13016 }
13017 }
13018 }
13019 impl Default for wire_cst_sdk_event {
13020 fn default() -> Self {
13021 Self::new_with_null_ptr()
13022 }
13023 }
13024 impl NewWithNullPtr for wire_cst_send_destination {
13025 fn new_with_null_ptr() -> Self {
13026 Self {
13027 tag: -1,
13028 kind: SendDestinationKind { nil__: () },
13029 }
13030 }
13031 }
13032 impl Default for wire_cst_send_destination {
13033 fn default() -> Self {
13034 Self::new_with_null_ptr()
13035 }
13036 }
13037 impl NewWithNullPtr for wire_cst_send_payment_request {
13038 fn new_with_null_ptr() -> Self {
13039 Self {
13040 prepare_response: Default::default(),
13041 use_asset_fees: core::ptr::null_mut(),
13042 }
13043 }
13044 }
13045 impl Default for wire_cst_send_payment_request {
13046 fn default() -> Self {
13047 Self::new_with_null_ptr()
13048 }
13049 }
13050 impl NewWithNullPtr for wire_cst_send_payment_response {
13051 fn new_with_null_ptr() -> Self {
13052 Self {
13053 payment: Default::default(),
13054 }
13055 }
13056 }
13057 impl Default for wire_cst_send_payment_response {
13058 fn default() -> Self {
13059 Self::new_with_null_ptr()
13060 }
13061 }
13062 impl NewWithNullPtr for wire_cst_sign_message_request {
13063 fn new_with_null_ptr() -> Self {
13064 Self {
13065 message: core::ptr::null_mut(),
13066 }
13067 }
13068 }
13069 impl Default for wire_cst_sign_message_request {
13070 fn default() -> Self {
13071 Self::new_with_null_ptr()
13072 }
13073 }
13074 impl NewWithNullPtr for wire_cst_sign_message_response {
13075 fn new_with_null_ptr() -> Self {
13076 Self {
13077 signature: core::ptr::null_mut(),
13078 }
13079 }
13080 }
13081 impl Default for wire_cst_sign_message_response {
13082 fn default() -> Self {
13083 Self::new_with_null_ptr()
13084 }
13085 }
13086 impl NewWithNullPtr for wire_cst_success_action {
13087 fn new_with_null_ptr() -> Self {
13088 Self {
13089 tag: -1,
13090 kind: SuccessActionKind { nil__: () },
13091 }
13092 }
13093 }
13094 impl Default for wire_cst_success_action {
13095 fn default() -> Self {
13096 Self::new_with_null_ptr()
13097 }
13098 }
13099 impl NewWithNullPtr for wire_cst_success_action_processed {
13100 fn new_with_null_ptr() -> Self {
13101 Self {
13102 tag: -1,
13103 kind: SuccessActionProcessedKind { nil__: () },
13104 }
13105 }
13106 }
13107 impl Default for wire_cst_success_action_processed {
13108 fn default() -> Self {
13109 Self::new_with_null_ptr()
13110 }
13111 }
13112 impl NewWithNullPtr for wire_cst_symbol {
13113 fn new_with_null_ptr() -> Self {
13114 Self {
13115 grapheme: core::ptr::null_mut(),
13116 template: core::ptr::null_mut(),
13117 rtl: core::ptr::null_mut(),
13118 position: core::ptr::null_mut(),
13119 }
13120 }
13121 }
13122 impl Default for wire_cst_symbol {
13123 fn default() -> Self {
13124 Self::new_with_null_ptr()
13125 }
13126 }
13127 impl NewWithNullPtr for wire_cst_url_success_action_data {
13128 fn new_with_null_ptr() -> Self {
13129 Self {
13130 description: core::ptr::null_mut(),
13131 url: core::ptr::null_mut(),
13132 matches_callback_domain: Default::default(),
13133 }
13134 }
13135 }
13136 impl Default for wire_cst_url_success_action_data {
13137 fn default() -> Self {
13138 Self::new_with_null_ptr()
13139 }
13140 }
13141 impl NewWithNullPtr for wire_cst_wallet_info {
13142 fn new_with_null_ptr() -> Self {
13143 Self {
13144 balance_sat: Default::default(),
13145 pending_send_sat: Default::default(),
13146 pending_receive_sat: Default::default(),
13147 fingerprint: core::ptr::null_mut(),
13148 pubkey: core::ptr::null_mut(),
13149 asset_balances: core::ptr::null_mut(),
13150 }
13151 }
13152 }
13153 impl Default for wire_cst_wallet_info {
13154 fn default() -> Self {
13155 Self::new_with_null_ptr()
13156 }
13157 }
13158
13159 #[unsafe(no_mangle)]
13160 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees(
13161 port_: i64,
13162 that: usize,
13163 req: *mut wire_cst_accept_payment_proposed_fees_request,
13164 ) {
13165 wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(port_, that, req)
13166 }
13167
13168 #[unsafe(no_mangle)]
13169 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_add_event_listener(
13170 port_: i64,
13171 that: usize,
13172 listener: *mut wire_cst_list_prim_u_8_strict,
13173 ) {
13174 wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(port_, that, listener)
13175 }
13176
13177 #[unsafe(no_mangle)]
13178 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_backup(
13179 that: usize,
13180 req: *mut wire_cst_backup_request,
13181 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13182 wire__crate__bindings__BindingLiquidSdk_backup_impl(that, req)
13183 }
13184
13185 #[unsafe(no_mangle)]
13186 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_buy_bitcoin(
13187 port_: i64,
13188 that: usize,
13189 req: *mut wire_cst_buy_bitcoin_request,
13190 ) {
13191 wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(port_, that, req)
13192 }
13193
13194 #[unsafe(no_mangle)]
13195 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_check_message(
13196 that: usize,
13197 req: *mut wire_cst_check_message_request,
13198 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13199 wire__crate__bindings__BindingLiquidSdk_check_message_impl(that, req)
13200 }
13201
13202 #[unsafe(no_mangle)]
13203 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice(
13204 port_: i64,
13205 that: usize,
13206 req: *mut wire_cst_create_bolt_12_invoice_request,
13207 ) {
13208 wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(port_, that, req)
13209 }
13210
13211 #[unsafe(no_mangle)]
13212 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_disconnect(
13213 port_: i64,
13214 that: usize,
13215 ) {
13216 wire__crate__bindings__BindingLiquidSdk_disconnect_impl(port_, that)
13217 }
13218
13219 #[unsafe(no_mangle)]
13220 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache(
13221 that: usize,
13222 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13223 wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(that)
13224 }
13225
13226 #[unsafe(no_mangle)]
13227 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates(
13228 port_: i64,
13229 that: usize,
13230 ) {
13231 wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(port_, that)
13232 }
13233
13234 #[unsafe(no_mangle)]
13235 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
13236 port_: i64,
13237 that: usize,
13238 ) {
13239 wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(port_, that)
13240 }
13241
13242 #[unsafe(no_mangle)]
13243 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
13244 port_: i64,
13245 that: usize,
13246 ) {
13247 wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(port_, that)
13248 }
13249
13250 #[unsafe(no_mangle)]
13251 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees(
13252 port_: i64,
13253 that: usize,
13254 req: *mut wire_cst_fetch_payment_proposed_fees_request,
13255 ) {
13256 wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(port_, that, req)
13257 }
13258
13259 #[unsafe(no_mangle)]
13260 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info(
13261 port_: i64,
13262 that: usize,
13263 ) {
13264 wire__crate__bindings__BindingLiquidSdk_get_info_impl(port_, that)
13265 }
13266
13267 #[unsafe(no_mangle)]
13268 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_payment(
13269 port_: i64,
13270 that: usize,
13271 req: *mut wire_cst_get_payment_request,
13272 ) {
13273 wire__crate__bindings__BindingLiquidSdk_get_payment_impl(port_, that, req)
13274 }
13275
13276 #[unsafe(no_mangle)]
13277 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies(
13278 port_: i64,
13279 that: usize,
13280 ) {
13281 wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(port_, that)
13282 }
13283
13284 #[unsafe(no_mangle)]
13285 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_payments(
13286 port_: i64,
13287 that: usize,
13288 req: *mut wire_cst_list_payments_request,
13289 ) {
13290 wire__crate__bindings__BindingLiquidSdk_list_payments_impl(port_, that, req)
13291 }
13292
13293 #[unsafe(no_mangle)]
13294 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_refundables(
13295 port_: i64,
13296 that: usize,
13297 ) {
13298 wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(port_, that)
13299 }
13300
13301 #[unsafe(no_mangle)]
13302 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_auth(
13303 port_: i64,
13304 that: usize,
13305 req_data: *mut wire_cst_ln_url_auth_request_data,
13306 ) {
13307 wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(port_, that, req_data)
13308 }
13309
13310 #[unsafe(no_mangle)]
13311 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_pay(
13312 port_: i64,
13313 that: usize,
13314 req: *mut wire_cst_ln_url_pay_request,
13315 ) {
13316 wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(port_, that, req)
13317 }
13318
13319 #[unsafe(no_mangle)]
13320 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw(
13321 port_: i64,
13322 that: usize,
13323 req: *mut wire_cst_ln_url_withdraw_request,
13324 ) {
13325 wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(port_, that, req)
13326 }
13327
13328 #[unsafe(no_mangle)]
13329 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_parse(
13330 port_: i64,
13331 that: usize,
13332 input: *mut wire_cst_list_prim_u_8_strict,
13333 ) {
13334 wire__crate__bindings__BindingLiquidSdk_parse_impl(port_, that, input)
13335 }
13336
13337 #[unsafe(no_mangle)]
13338 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_pay_onchain(
13339 port_: i64,
13340 that: usize,
13341 req: *mut wire_cst_pay_onchain_request,
13342 ) {
13343 wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(port_, that, req)
13344 }
13345
13346 #[unsafe(no_mangle)]
13347 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin(
13348 port_: i64,
13349 that: usize,
13350 req: *mut wire_cst_prepare_buy_bitcoin_request,
13351 ) {
13352 wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(port_, that, req)
13353 }
13354
13355 #[unsafe(no_mangle)]
13356 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay(
13357 port_: i64,
13358 that: usize,
13359 req: *mut wire_cst_prepare_ln_url_pay_request,
13360 ) {
13361 wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(port_, that, req)
13362 }
13363
13364 #[unsafe(no_mangle)]
13365 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain(
13366 port_: i64,
13367 that: usize,
13368 req: *mut wire_cst_prepare_pay_onchain_request,
13369 ) {
13370 wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(port_, that, req)
13371 }
13372
13373 #[unsafe(no_mangle)]
13374 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment(
13375 port_: i64,
13376 that: usize,
13377 req: *mut wire_cst_prepare_receive_request,
13378 ) {
13379 wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(port_, that, req)
13380 }
13381
13382 #[unsafe(no_mangle)]
13383 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_refund(
13384 port_: i64,
13385 that: usize,
13386 req: *mut wire_cst_prepare_refund_request,
13387 ) {
13388 wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(port_, that, req)
13389 }
13390
13391 #[unsafe(no_mangle)]
13392 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_send_payment(
13393 port_: i64,
13394 that: usize,
13395 req: *mut wire_cst_prepare_send_request,
13396 ) {
13397 wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(port_, that, req)
13398 }
13399
13400 #[unsafe(no_mangle)]
13401 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_receive_payment(
13402 port_: i64,
13403 that: usize,
13404 req: *mut wire_cst_receive_payment_request,
13405 ) {
13406 wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(port_, that, req)
13407 }
13408
13409 #[unsafe(no_mangle)]
13410 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_recommended_fees(
13411 port_: i64,
13412 that: usize,
13413 ) {
13414 wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(port_, that)
13415 }
13416
13417 #[unsafe(no_mangle)]
13418 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_refund(
13419 port_: i64,
13420 that: usize,
13421 req: *mut wire_cst_refund_request,
13422 ) {
13423 wire__crate__bindings__BindingLiquidSdk_refund_impl(port_, that, req)
13424 }
13425
13426 #[unsafe(no_mangle)]
13427 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_register_webhook(
13428 port_: i64,
13429 that: usize,
13430 webhook_url: *mut wire_cst_list_prim_u_8_strict,
13431 ) {
13432 wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(port_, that, webhook_url)
13433 }
13434
13435 #[unsafe(no_mangle)]
13436 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps(
13437 port_: i64,
13438 that: usize,
13439 ) {
13440 wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(port_, that)
13441 }
13442
13443 #[unsafe(no_mangle)]
13444 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_restore(
13445 that: usize,
13446 req: *mut wire_cst_restore_request,
13447 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13448 wire__crate__bindings__BindingLiquidSdk_restore_impl(that, req)
13449 }
13450
13451 #[unsafe(no_mangle)]
13452 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_send_payment(
13453 port_: i64,
13454 that: usize,
13455 req: *mut wire_cst_send_payment_request,
13456 ) {
13457 wire__crate__bindings__BindingLiquidSdk_send_payment_impl(port_, that, req)
13458 }
13459
13460 #[unsafe(no_mangle)]
13461 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sign_message(
13462 that: usize,
13463 req: *mut wire_cst_sign_message_request,
13464 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13465 wire__crate__bindings__BindingLiquidSdk_sign_message_impl(that, req)
13466 }
13467
13468 #[unsafe(no_mangle)]
13469 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sync(
13470 port_: i64,
13471 that: usize,
13472 ) {
13473 wire__crate__bindings__BindingLiquidSdk_sync_impl(port_, that)
13474 }
13475
13476 #[unsafe(no_mangle)]
13477 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_unregister_webhook(
13478 port_: i64,
13479 that: usize,
13480 ) {
13481 wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(port_, that)
13482 }
13483
13484 #[unsafe(no_mangle)]
13485 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__binding_event_listener_on_event(
13486 port_: i64,
13487 that: *mut wire_cst_binding_event_listener,
13488 e: *mut wire_cst_sdk_event,
13489 ) {
13490 wire__crate__bindings__binding_event_listener_on_event_impl(port_, that, e)
13491 }
13492
13493 #[unsafe(no_mangle)]
13494 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__breez_log_stream(
13495 port_: i64,
13496 s: *mut wire_cst_list_prim_u_8_strict,
13497 ) {
13498 wire__crate__bindings__breez_log_stream_impl(port_, s)
13499 }
13500
13501 #[unsafe(no_mangle)]
13502 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__connect(
13503 port_: i64,
13504 req: *mut wire_cst_connect_request,
13505 ) {
13506 wire__crate__bindings__connect_impl(port_, req)
13507 }
13508
13509 #[unsafe(no_mangle)]
13510 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__default_config(
13511 network: i32,
13512 breez_api_key: *mut wire_cst_list_prim_u_8_strict,
13513 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13514 wire__crate__bindings__default_config_impl(network, breez_api_key)
13515 }
13516
13517 #[unsafe(no_mangle)]
13518 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__parse_invoice(
13519 input: *mut wire_cst_list_prim_u_8_strict,
13520 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13521 wire__crate__bindings__parse_invoice_impl(input)
13522 }
13523
13524 #[unsafe(no_mangle)]
13525 pub extern "C" fn frbgen_breez_liquid_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13526 ptr: *const std::ffi::c_void,
13527 ) {
13528 unsafe {
13529 StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::increment_strong_count(ptr as _);
13530 }
13531 }
13532
13533 #[unsafe(no_mangle)]
13534 pub extern "C" fn frbgen_breez_liquid_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13535 ptr: *const std::ffi::c_void,
13536 ) {
13537 unsafe {
13538 StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::decrement_strong_count(ptr as _);
13539 }
13540 }
13541
13542 #[unsafe(no_mangle)]
13543 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_accept_payment_proposed_fees_request(
13544 ) -> *mut wire_cst_accept_payment_proposed_fees_request {
13545 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13546 wire_cst_accept_payment_proposed_fees_request::new_with_null_ptr(),
13547 )
13548 }
13549
13550 #[unsafe(no_mangle)]
13551 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data(
13552 ) -> *mut wire_cst_aes_success_action_data {
13553 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13554 wire_cst_aes_success_action_data::new_with_null_ptr(),
13555 )
13556 }
13557
13558 #[unsafe(no_mangle)]
13559 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_decrypted(
13560 ) -> *mut wire_cst_aes_success_action_data_decrypted {
13561 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13562 wire_cst_aes_success_action_data_decrypted::new_with_null_ptr(),
13563 )
13564 }
13565
13566 #[unsafe(no_mangle)]
13567 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_result(
13568 ) -> *mut wire_cst_aes_success_action_data_result {
13569 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13570 wire_cst_aes_success_action_data_result::new_with_null_ptr(),
13571 )
13572 }
13573
13574 #[unsafe(no_mangle)]
13575 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_amount() -> *mut wire_cst_amount {
13576 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_amount::new_with_null_ptr())
13577 }
13578
13579 #[unsafe(no_mangle)]
13580 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_asset_info(
13581 ) -> *mut wire_cst_asset_info {
13582 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13583 wire_cst_asset_info::new_with_null_ptr(),
13584 )
13585 }
13586
13587 #[unsafe(no_mangle)]
13588 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_backup_request(
13589 ) -> *mut wire_cst_backup_request {
13590 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13591 wire_cst_backup_request::new_with_null_ptr(),
13592 )
13593 }
13594
13595 #[unsafe(no_mangle)]
13596 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_binding_event_listener(
13597 ) -> *mut wire_cst_binding_event_listener {
13598 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13599 wire_cst_binding_event_listener::new_with_null_ptr(),
13600 )
13601 }
13602
13603 #[unsafe(no_mangle)]
13604 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bitcoin_address_data(
13605 ) -> *mut wire_cst_bitcoin_address_data {
13606 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13607 wire_cst_bitcoin_address_data::new_with_null_ptr(),
13608 )
13609 }
13610
13611 #[unsafe(no_mangle)]
13612 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bool(value: bool) -> *mut bool {
13613 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13614 }
13615
13616 #[unsafe(no_mangle)]
13617 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_buy_bitcoin_request(
13618 ) -> *mut wire_cst_buy_bitcoin_request {
13619 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13620 wire_cst_buy_bitcoin_request::new_with_null_ptr(),
13621 )
13622 }
13623
13624 #[unsafe(no_mangle)]
13625 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_check_message_request(
13626 ) -> *mut wire_cst_check_message_request {
13627 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13628 wire_cst_check_message_request::new_with_null_ptr(),
13629 )
13630 }
13631
13632 #[unsafe(no_mangle)]
13633 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_connect_request(
13634 ) -> *mut wire_cst_connect_request {
13635 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13636 wire_cst_connect_request::new_with_null_ptr(),
13637 )
13638 }
13639
13640 #[unsafe(no_mangle)]
13641 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_create_bolt_12_invoice_request(
13642 ) -> *mut wire_cst_create_bolt_12_invoice_request {
13643 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13644 wire_cst_create_bolt_12_invoice_request::new_with_null_ptr(),
13645 )
13646 }
13647
13648 #[unsafe(no_mangle)]
13649 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_f_64(value: f64) -> *mut f64 {
13650 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13651 }
13652
13653 #[unsafe(no_mangle)]
13654 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_fetch_payment_proposed_fees_request(
13655 ) -> *mut wire_cst_fetch_payment_proposed_fees_request {
13656 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13657 wire_cst_fetch_payment_proposed_fees_request::new_with_null_ptr(),
13658 )
13659 }
13660
13661 #[unsafe(no_mangle)]
13662 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_get_payment_request(
13663 ) -> *mut wire_cst_get_payment_request {
13664 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13665 wire_cst_get_payment_request::new_with_null_ptr(),
13666 )
13667 }
13668
13669 #[unsafe(no_mangle)]
13670 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_i_64(value: i64) -> *mut i64 {
13671 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13672 }
13673
13674 #[unsafe(no_mangle)]
13675 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_liquid_address_data(
13676 ) -> *mut wire_cst_liquid_address_data {
13677 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13678 wire_cst_liquid_address_data::new_with_null_ptr(),
13679 )
13680 }
13681
13682 #[unsafe(no_mangle)]
13683 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payment_details(
13684 ) -> *mut wire_cst_list_payment_details {
13685 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13686 wire_cst_list_payment_details::new_with_null_ptr(),
13687 )
13688 }
13689
13690 #[unsafe(no_mangle)]
13691 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payments_request(
13692 ) -> *mut wire_cst_list_payments_request {
13693 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13694 wire_cst_list_payments_request::new_with_null_ptr(),
13695 )
13696 }
13697
13698 #[unsafe(no_mangle)]
13699 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_invoice(
13700 ) -> *mut wire_cst_ln_invoice {
13701 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13702 wire_cst_ln_invoice::new_with_null_ptr(),
13703 )
13704 }
13705
13706 #[unsafe(no_mangle)]
13707 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_offer() -> *mut wire_cst_ln_offer {
13708 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_ln_offer::new_with_null_ptr())
13709 }
13710
13711 #[unsafe(no_mangle)]
13712 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_auth_request_data(
13713 ) -> *mut wire_cst_ln_url_auth_request_data {
13714 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13715 wire_cst_ln_url_auth_request_data::new_with_null_ptr(),
13716 )
13717 }
13718
13719 #[unsafe(no_mangle)]
13720 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_error_data(
13721 ) -> *mut wire_cst_ln_url_error_data {
13722 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13723 wire_cst_ln_url_error_data::new_with_null_ptr(),
13724 )
13725 }
13726
13727 #[unsafe(no_mangle)]
13728 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_info(
13729 ) -> *mut wire_cst_ln_url_info {
13730 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13731 wire_cst_ln_url_info::new_with_null_ptr(),
13732 )
13733 }
13734
13735 #[unsafe(no_mangle)]
13736 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_error_data(
13737 ) -> *mut wire_cst_ln_url_pay_error_data {
13738 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13739 wire_cst_ln_url_pay_error_data::new_with_null_ptr(),
13740 )
13741 }
13742
13743 #[unsafe(no_mangle)]
13744 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request(
13745 ) -> *mut wire_cst_ln_url_pay_request {
13746 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13747 wire_cst_ln_url_pay_request::new_with_null_ptr(),
13748 )
13749 }
13750
13751 #[unsafe(no_mangle)]
13752 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request_data(
13753 ) -> *mut wire_cst_ln_url_pay_request_data {
13754 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13755 wire_cst_ln_url_pay_request_data::new_with_null_ptr(),
13756 )
13757 }
13758
13759 #[unsafe(no_mangle)]
13760 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_success_data(
13761 ) -> *mut wire_cst_ln_url_pay_success_data {
13762 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13763 wire_cst_ln_url_pay_success_data::new_with_null_ptr(),
13764 )
13765 }
13766
13767 #[unsafe(no_mangle)]
13768 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request(
13769 ) -> *mut wire_cst_ln_url_withdraw_request {
13770 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13771 wire_cst_ln_url_withdraw_request::new_with_null_ptr(),
13772 )
13773 }
13774
13775 #[unsafe(no_mangle)]
13776 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request_data(
13777 ) -> *mut wire_cst_ln_url_withdraw_request_data {
13778 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13779 wire_cst_ln_url_withdraw_request_data::new_with_null_ptr(),
13780 )
13781 }
13782
13783 #[unsafe(no_mangle)]
13784 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_success_data(
13785 ) -> *mut wire_cst_ln_url_withdraw_success_data {
13786 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13787 wire_cst_ln_url_withdraw_success_data::new_with_null_ptr(),
13788 )
13789 }
13790
13791 #[unsafe(no_mangle)]
13792 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_message_success_action_data(
13793 ) -> *mut wire_cst_message_success_action_data {
13794 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13795 wire_cst_message_success_action_data::new_with_null_ptr(),
13796 )
13797 }
13798
13799 #[unsafe(no_mangle)]
13800 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_amount(
13801 ) -> *mut wire_cst_pay_amount {
13802 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13803 wire_cst_pay_amount::new_with_null_ptr(),
13804 )
13805 }
13806
13807 #[unsafe(no_mangle)]
13808 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_onchain_request(
13809 ) -> *mut wire_cst_pay_onchain_request {
13810 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13811 wire_cst_pay_onchain_request::new_with_null_ptr(),
13812 )
13813 }
13814
13815 #[unsafe(no_mangle)]
13816 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_payment() -> *mut wire_cst_payment {
13817 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_payment::new_with_null_ptr())
13818 }
13819
13820 #[unsafe(no_mangle)]
13821 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_buy_bitcoin_request(
13822 ) -> *mut wire_cst_prepare_buy_bitcoin_request {
13823 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13824 wire_cst_prepare_buy_bitcoin_request::new_with_null_ptr(),
13825 )
13826 }
13827
13828 #[unsafe(no_mangle)]
13829 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_ln_url_pay_request(
13830 ) -> *mut wire_cst_prepare_ln_url_pay_request {
13831 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13832 wire_cst_prepare_ln_url_pay_request::new_with_null_ptr(),
13833 )
13834 }
13835
13836 #[unsafe(no_mangle)]
13837 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_pay_onchain_request(
13838 ) -> *mut wire_cst_prepare_pay_onchain_request {
13839 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13840 wire_cst_prepare_pay_onchain_request::new_with_null_ptr(),
13841 )
13842 }
13843
13844 #[unsafe(no_mangle)]
13845 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_receive_request(
13846 ) -> *mut wire_cst_prepare_receive_request {
13847 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13848 wire_cst_prepare_receive_request::new_with_null_ptr(),
13849 )
13850 }
13851
13852 #[unsafe(no_mangle)]
13853 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_refund_request(
13854 ) -> *mut wire_cst_prepare_refund_request {
13855 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13856 wire_cst_prepare_refund_request::new_with_null_ptr(),
13857 )
13858 }
13859
13860 #[unsafe(no_mangle)]
13861 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_send_request(
13862 ) -> *mut wire_cst_prepare_send_request {
13863 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13864 wire_cst_prepare_send_request::new_with_null_ptr(),
13865 )
13866 }
13867
13868 #[unsafe(no_mangle)]
13869 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_amount(
13870 ) -> *mut wire_cst_receive_amount {
13871 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13872 wire_cst_receive_amount::new_with_null_ptr(),
13873 )
13874 }
13875
13876 #[unsafe(no_mangle)]
13877 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_payment_request(
13878 ) -> *mut wire_cst_receive_payment_request {
13879 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13880 wire_cst_receive_payment_request::new_with_null_ptr(),
13881 )
13882 }
13883
13884 #[unsafe(no_mangle)]
13885 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_refund_request(
13886 ) -> *mut wire_cst_refund_request {
13887 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13888 wire_cst_refund_request::new_with_null_ptr(),
13889 )
13890 }
13891
13892 #[unsafe(no_mangle)]
13893 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_restore_request(
13894 ) -> *mut wire_cst_restore_request {
13895 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13896 wire_cst_restore_request::new_with_null_ptr(),
13897 )
13898 }
13899
13900 #[unsafe(no_mangle)]
13901 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sdk_event() -> *mut wire_cst_sdk_event
13902 {
13903 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_sdk_event::new_with_null_ptr())
13904 }
13905
13906 #[unsafe(no_mangle)]
13907 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_send_payment_request(
13908 ) -> *mut wire_cst_send_payment_request {
13909 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13910 wire_cst_send_payment_request::new_with_null_ptr(),
13911 )
13912 }
13913
13914 #[unsafe(no_mangle)]
13915 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sign_message_request(
13916 ) -> *mut wire_cst_sign_message_request {
13917 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13918 wire_cst_sign_message_request::new_with_null_ptr(),
13919 )
13920 }
13921
13922 #[unsafe(no_mangle)]
13923 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action(
13924 ) -> *mut wire_cst_success_action {
13925 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13926 wire_cst_success_action::new_with_null_ptr(),
13927 )
13928 }
13929
13930 #[unsafe(no_mangle)]
13931 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action_processed(
13932 ) -> *mut wire_cst_success_action_processed {
13933 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13934 wire_cst_success_action_processed::new_with_null_ptr(),
13935 )
13936 }
13937
13938 #[unsafe(no_mangle)]
13939 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_symbol() -> *mut wire_cst_symbol {
13940 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_symbol::new_with_null_ptr())
13941 }
13942
13943 #[unsafe(no_mangle)]
13944 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_32(value: u32) -> *mut u32 {
13945 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13946 }
13947
13948 #[unsafe(no_mangle)]
13949 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_64(value: u64) -> *mut u64 {
13950 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13951 }
13952
13953 #[unsafe(no_mangle)]
13954 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_url_success_action_data(
13955 ) -> *mut wire_cst_url_success_action_data {
13956 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13957 wire_cst_url_success_action_data::new_with_null_ptr(),
13958 )
13959 }
13960
13961 #[unsafe(no_mangle)]
13962 pub extern "C" fn frbgen_breez_liquid_cst_new_list_String(
13963 len: i32,
13964 ) -> *mut wire_cst_list_String {
13965 let wrap = wire_cst_list_String {
13966 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13967 <*mut wire_cst_list_prim_u_8_strict>::new_with_null_ptr(),
13968 len,
13969 ),
13970 len,
13971 };
13972 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13973 }
13974
13975 #[unsafe(no_mangle)]
13976 pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_balance(
13977 len: i32,
13978 ) -> *mut wire_cst_list_asset_balance {
13979 let wrap = wire_cst_list_asset_balance {
13980 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13981 <wire_cst_asset_balance>::new_with_null_ptr(),
13982 len,
13983 ),
13984 len,
13985 };
13986 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13987 }
13988
13989 #[unsafe(no_mangle)]
13990 pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_metadata(
13991 len: i32,
13992 ) -> *mut wire_cst_list_asset_metadata {
13993 let wrap = wire_cst_list_asset_metadata {
13994 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13995 <wire_cst_asset_metadata>::new_with_null_ptr(),
13996 len,
13997 ),
13998 len,
13999 };
14000 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14001 }
14002
14003 #[unsafe(no_mangle)]
14004 pub extern "C" fn frbgen_breez_liquid_cst_new_list_external_input_parser(
14005 len: i32,
14006 ) -> *mut wire_cst_list_external_input_parser {
14007 let wrap = wire_cst_list_external_input_parser {
14008 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14009 <wire_cst_external_input_parser>::new_with_null_ptr(),
14010 len,
14011 ),
14012 len,
14013 };
14014 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14015 }
14016
14017 #[unsafe(no_mangle)]
14018 pub extern "C" fn frbgen_breez_liquid_cst_new_list_fiat_currency(
14019 len: i32,
14020 ) -> *mut wire_cst_list_fiat_currency {
14021 let wrap = wire_cst_list_fiat_currency {
14022 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14023 <wire_cst_fiat_currency>::new_with_null_ptr(),
14024 len,
14025 ),
14026 len,
14027 };
14028 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14029 }
14030
14031 #[unsafe(no_mangle)]
14032 pub extern "C" fn frbgen_breez_liquid_cst_new_list_ln_offer_blinded_path(
14033 len: i32,
14034 ) -> *mut wire_cst_list_ln_offer_blinded_path {
14035 let wrap = wire_cst_list_ln_offer_blinded_path {
14036 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14037 <wire_cst_ln_offer_blinded_path>::new_with_null_ptr(),
14038 len,
14039 ),
14040 len,
14041 };
14042 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14043 }
14044
14045 #[unsafe(no_mangle)]
14046 pub extern "C" fn frbgen_breez_liquid_cst_new_list_locale_overrides(
14047 len: i32,
14048 ) -> *mut wire_cst_list_locale_overrides {
14049 let wrap = wire_cst_list_locale_overrides {
14050 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14051 <wire_cst_locale_overrides>::new_with_null_ptr(),
14052 len,
14053 ),
14054 len,
14055 };
14056 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14057 }
14058
14059 #[unsafe(no_mangle)]
14060 pub extern "C" fn frbgen_breez_liquid_cst_new_list_localized_name(
14061 len: i32,
14062 ) -> *mut wire_cst_list_localized_name {
14063 let wrap = wire_cst_list_localized_name {
14064 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14065 <wire_cst_localized_name>::new_with_null_ptr(),
14066 len,
14067 ),
14068 len,
14069 };
14070 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14071 }
14072
14073 #[unsafe(no_mangle)]
14074 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment(
14075 len: i32,
14076 ) -> *mut wire_cst_list_payment {
14077 let wrap = wire_cst_list_payment {
14078 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14079 <wire_cst_payment>::new_with_null_ptr(),
14080 len,
14081 ),
14082 len,
14083 };
14084 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14085 }
14086
14087 #[unsafe(no_mangle)]
14088 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_state(
14089 len: i32,
14090 ) -> *mut wire_cst_list_payment_state {
14091 let wrap = wire_cst_list_payment_state {
14092 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14093 len,
14094 };
14095 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14096 }
14097
14098 #[unsafe(no_mangle)]
14099 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_type(
14100 len: i32,
14101 ) -> *mut wire_cst_list_payment_type {
14102 let wrap = wire_cst_list_payment_type {
14103 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14104 len,
14105 };
14106 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14107 }
14108
14109 #[unsafe(no_mangle)]
14110 pub extern "C" fn frbgen_breez_liquid_cst_new_list_prim_u_8_strict(
14111 len: i32,
14112 ) -> *mut wire_cst_list_prim_u_8_strict {
14113 let ans = wire_cst_list_prim_u_8_strict {
14114 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14115 len,
14116 };
14117 flutter_rust_bridge::for_generated::new_leak_box_ptr(ans)
14118 }
14119
14120 #[unsafe(no_mangle)]
14121 pub extern "C" fn frbgen_breez_liquid_cst_new_list_rate(len: i32) -> *mut wire_cst_list_rate {
14122 let wrap = wire_cst_list_rate {
14123 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14124 <wire_cst_rate>::new_with_null_ptr(),
14125 len,
14126 ),
14127 len,
14128 };
14129 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14130 }
14131
14132 #[unsafe(no_mangle)]
14133 pub extern "C" fn frbgen_breez_liquid_cst_new_list_refundable_swap(
14134 len: i32,
14135 ) -> *mut wire_cst_list_refundable_swap {
14136 let wrap = wire_cst_list_refundable_swap {
14137 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14138 <wire_cst_refundable_swap>::new_with_null_ptr(),
14139 len,
14140 ),
14141 len,
14142 };
14143 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14144 }
14145
14146 #[unsafe(no_mangle)]
14147 pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint(
14148 len: i32,
14149 ) -> *mut wire_cst_list_route_hint {
14150 let wrap = wire_cst_list_route_hint {
14151 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14152 <wire_cst_route_hint>::new_with_null_ptr(),
14153 len,
14154 ),
14155 len,
14156 };
14157 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14158 }
14159
14160 #[unsafe(no_mangle)]
14161 pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint_hop(
14162 len: i32,
14163 ) -> *mut wire_cst_list_route_hint_hop {
14164 let wrap = wire_cst_list_route_hint_hop {
14165 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14166 <wire_cst_route_hint_hop>::new_with_null_ptr(),
14167 len,
14168 ),
14169 len,
14170 };
14171 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14172 }
14173
14174 #[repr(C)]
14175 #[derive(Clone, Copy)]
14176 pub struct wire_cst_accept_payment_proposed_fees_request {
14177 response: wire_cst_fetch_payment_proposed_fees_response,
14178 }
14179 #[repr(C)]
14180 #[derive(Clone, Copy)]
14181 pub struct wire_cst_aes_success_action_data {
14182 description: *mut wire_cst_list_prim_u_8_strict,
14183 ciphertext: *mut wire_cst_list_prim_u_8_strict,
14184 iv: *mut wire_cst_list_prim_u_8_strict,
14185 }
14186 #[repr(C)]
14187 #[derive(Clone, Copy)]
14188 pub struct wire_cst_aes_success_action_data_decrypted {
14189 description: *mut wire_cst_list_prim_u_8_strict,
14190 plaintext: *mut wire_cst_list_prim_u_8_strict,
14191 }
14192 #[repr(C)]
14193 #[derive(Clone, Copy)]
14194 pub struct wire_cst_aes_success_action_data_result {
14195 tag: i32,
14196 kind: AesSuccessActionDataResultKind,
14197 }
14198 #[repr(C)]
14199 #[derive(Clone, Copy)]
14200 pub union AesSuccessActionDataResultKind {
14201 Decrypted: wire_cst_AesSuccessActionDataResult_Decrypted,
14202 ErrorStatus: wire_cst_AesSuccessActionDataResult_ErrorStatus,
14203 nil__: (),
14204 }
14205 #[repr(C)]
14206 #[derive(Clone, Copy)]
14207 pub struct wire_cst_AesSuccessActionDataResult_Decrypted {
14208 data: *mut wire_cst_aes_success_action_data_decrypted,
14209 }
14210 #[repr(C)]
14211 #[derive(Clone, Copy)]
14212 pub struct wire_cst_AesSuccessActionDataResult_ErrorStatus {
14213 reason: *mut wire_cst_list_prim_u_8_strict,
14214 }
14215 #[repr(C)]
14216 #[derive(Clone, Copy)]
14217 pub struct wire_cst_amount {
14218 tag: i32,
14219 kind: AmountKind,
14220 }
14221 #[repr(C)]
14222 #[derive(Clone, Copy)]
14223 pub union AmountKind {
14224 Bitcoin: wire_cst_Amount_Bitcoin,
14225 Currency: wire_cst_Amount_Currency,
14226 nil__: (),
14227 }
14228 #[repr(C)]
14229 #[derive(Clone, Copy)]
14230 pub struct wire_cst_Amount_Bitcoin {
14231 amount_msat: u64,
14232 }
14233 #[repr(C)]
14234 #[derive(Clone, Copy)]
14235 pub struct wire_cst_Amount_Currency {
14236 iso4217_code: *mut wire_cst_list_prim_u_8_strict,
14237 fractional_amount: u64,
14238 }
14239 #[repr(C)]
14240 #[derive(Clone, Copy)]
14241 pub struct wire_cst_asset_balance {
14242 asset_id: *mut wire_cst_list_prim_u_8_strict,
14243 balance_sat: u64,
14244 name: *mut wire_cst_list_prim_u_8_strict,
14245 ticker: *mut wire_cst_list_prim_u_8_strict,
14246 balance: *mut f64,
14247 }
14248 #[repr(C)]
14249 #[derive(Clone, Copy)]
14250 pub struct wire_cst_asset_info {
14251 name: *mut wire_cst_list_prim_u_8_strict,
14252 ticker: *mut wire_cst_list_prim_u_8_strict,
14253 amount: f64,
14254 fees: *mut f64,
14255 }
14256 #[repr(C)]
14257 #[derive(Clone, Copy)]
14258 pub struct wire_cst_asset_metadata {
14259 asset_id: *mut wire_cst_list_prim_u_8_strict,
14260 name: *mut wire_cst_list_prim_u_8_strict,
14261 ticker: *mut wire_cst_list_prim_u_8_strict,
14262 precision: u8,
14263 fiat_id: *mut wire_cst_list_prim_u_8_strict,
14264 }
14265 #[repr(C)]
14266 #[derive(Clone, Copy)]
14267 pub struct wire_cst_backup_request {
14268 backup_path: *mut wire_cst_list_prim_u_8_strict,
14269 }
14270 #[repr(C)]
14271 #[derive(Clone, Copy)]
14272 pub struct wire_cst_binding_event_listener {
14273 stream: *mut wire_cst_list_prim_u_8_strict,
14274 }
14275 #[repr(C)]
14276 #[derive(Clone, Copy)]
14277 pub struct wire_cst_bitcoin_address_data {
14278 address: *mut wire_cst_list_prim_u_8_strict,
14279 network: i32,
14280 amount_sat: *mut u64,
14281 label: *mut wire_cst_list_prim_u_8_strict,
14282 message: *mut wire_cst_list_prim_u_8_strict,
14283 }
14284 #[repr(C)]
14285 #[derive(Clone, Copy)]
14286 pub struct wire_cst_blockchain_explorer {
14287 tag: i32,
14288 kind: BlockchainExplorerKind,
14289 }
14290 #[repr(C)]
14291 #[derive(Clone, Copy)]
14292 pub union BlockchainExplorerKind {
14293 Electrum: wire_cst_BlockchainExplorer_Electrum,
14294 Esplora: wire_cst_BlockchainExplorer_Esplora,
14295 nil__: (),
14296 }
14297 #[repr(C)]
14298 #[derive(Clone, Copy)]
14299 pub struct wire_cst_BlockchainExplorer_Electrum {
14300 url: *mut wire_cst_list_prim_u_8_strict,
14301 }
14302 #[repr(C)]
14303 #[derive(Clone, Copy)]
14304 pub struct wire_cst_BlockchainExplorer_Esplora {
14305 url: *mut wire_cst_list_prim_u_8_strict,
14306 use_waterfalls: bool,
14307 }
14308 #[repr(C)]
14309 #[derive(Clone, Copy)]
14310 pub struct wire_cst_blockchain_info {
14311 liquid_tip: u32,
14312 bitcoin_tip: u32,
14313 }
14314 #[repr(C)]
14315 #[derive(Clone, Copy)]
14316 pub struct wire_cst_buy_bitcoin_request {
14317 prepare_response: wire_cst_prepare_buy_bitcoin_response,
14318 redirect_url: *mut wire_cst_list_prim_u_8_strict,
14319 }
14320 #[repr(C)]
14321 #[derive(Clone, Copy)]
14322 pub struct wire_cst_check_message_request {
14323 message: *mut wire_cst_list_prim_u_8_strict,
14324 pubkey: *mut wire_cst_list_prim_u_8_strict,
14325 signature: *mut wire_cst_list_prim_u_8_strict,
14326 }
14327 #[repr(C)]
14328 #[derive(Clone, Copy)]
14329 pub struct wire_cst_check_message_response {
14330 is_valid: bool,
14331 }
14332 #[repr(C)]
14333 #[derive(Clone, Copy)]
14334 pub struct wire_cst_config {
14335 liquid_explorer: wire_cst_blockchain_explorer,
14336 bitcoin_explorer: wire_cst_blockchain_explorer,
14337 working_dir: *mut wire_cst_list_prim_u_8_strict,
14338 network: i32,
14339 payment_timeout_sec: u64,
14340 sync_service_url: *mut wire_cst_list_prim_u_8_strict,
14341 zero_conf_max_amount_sat: *mut u64,
14342 breez_api_key: *mut wire_cst_list_prim_u_8_strict,
14343 external_input_parsers: *mut wire_cst_list_external_input_parser,
14344 use_default_external_input_parsers: bool,
14345 onchain_fee_rate_leeway_sat_per_vbyte: *mut u32,
14346 asset_metadata: *mut wire_cst_list_asset_metadata,
14347 sideswap_api_key: *mut wire_cst_list_prim_u_8_strict,
14348 }
14349 #[repr(C)]
14350 #[derive(Clone, Copy)]
14351 pub struct wire_cst_connect_request {
14352 config: wire_cst_config,
14353 mnemonic: *mut wire_cst_list_prim_u_8_strict,
14354 passphrase: *mut wire_cst_list_prim_u_8_strict,
14355 seed: *mut wire_cst_list_prim_u_8_strict,
14356 }
14357 #[repr(C)]
14358 #[derive(Clone, Copy)]
14359 pub struct wire_cst_create_bolt_12_invoice_request {
14360 offer: *mut wire_cst_list_prim_u_8_strict,
14361 invoice_request: *mut wire_cst_list_prim_u_8_strict,
14362 }
14363 #[repr(C)]
14364 #[derive(Clone, Copy)]
14365 pub struct wire_cst_create_bolt_12_invoice_response {
14366 invoice: *mut wire_cst_list_prim_u_8_strict,
14367 }
14368 #[repr(C)]
14369 #[derive(Clone, Copy)]
14370 pub struct wire_cst_currency_info {
14371 name: *mut wire_cst_list_prim_u_8_strict,
14372 fraction_size: u32,
14373 spacing: *mut u32,
14374 symbol: *mut wire_cst_symbol,
14375 uniq_symbol: *mut wire_cst_symbol,
14376 localized_name: *mut wire_cst_list_localized_name,
14377 locale_overrides: *mut wire_cst_list_locale_overrides,
14378 }
14379 #[repr(C)]
14380 #[derive(Clone, Copy)]
14381 pub struct wire_cst_external_input_parser {
14382 provider_id: *mut wire_cst_list_prim_u_8_strict,
14383 input_regex: *mut wire_cst_list_prim_u_8_strict,
14384 parser_url: *mut wire_cst_list_prim_u_8_strict,
14385 }
14386 #[repr(C)]
14387 #[derive(Clone, Copy)]
14388 pub struct wire_cst_fetch_payment_proposed_fees_request {
14389 swap_id: *mut wire_cst_list_prim_u_8_strict,
14390 }
14391 #[repr(C)]
14392 #[derive(Clone, Copy)]
14393 pub struct wire_cst_fetch_payment_proposed_fees_response {
14394 swap_id: *mut wire_cst_list_prim_u_8_strict,
14395 fees_sat: u64,
14396 payer_amount_sat: u64,
14397 receiver_amount_sat: u64,
14398 }
14399 #[repr(C)]
14400 #[derive(Clone, Copy)]
14401 pub struct wire_cst_fiat_currency {
14402 id: *mut wire_cst_list_prim_u_8_strict,
14403 info: wire_cst_currency_info,
14404 }
14405 #[repr(C)]
14406 #[derive(Clone, Copy)]
14407 pub struct wire_cst_get_info_response {
14408 wallet_info: wire_cst_wallet_info,
14409 blockchain_info: wire_cst_blockchain_info,
14410 }
14411 #[repr(C)]
14412 #[derive(Clone, Copy)]
14413 pub struct wire_cst_get_payment_request {
14414 tag: i32,
14415 kind: GetPaymentRequestKind,
14416 }
14417 #[repr(C)]
14418 #[derive(Clone, Copy)]
14419 pub union GetPaymentRequestKind {
14420 PaymentHash: wire_cst_GetPaymentRequest_PaymentHash,
14421 SwapId: wire_cst_GetPaymentRequest_SwapId,
14422 nil__: (),
14423 }
14424 #[repr(C)]
14425 #[derive(Clone, Copy)]
14426 pub struct wire_cst_GetPaymentRequest_PaymentHash {
14427 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14428 }
14429 #[repr(C)]
14430 #[derive(Clone, Copy)]
14431 pub struct wire_cst_GetPaymentRequest_SwapId {
14432 swap_id: *mut wire_cst_list_prim_u_8_strict,
14433 }
14434 #[repr(C)]
14435 #[derive(Clone, Copy)]
14436 pub struct wire_cst_input_type {
14437 tag: i32,
14438 kind: InputTypeKind,
14439 }
14440 #[repr(C)]
14441 #[derive(Clone, Copy)]
14442 pub union InputTypeKind {
14443 BitcoinAddress: wire_cst_InputType_BitcoinAddress,
14444 LiquidAddress: wire_cst_InputType_LiquidAddress,
14445 Bolt11: wire_cst_InputType_Bolt11,
14446 Bolt12Offer: wire_cst_InputType_Bolt12Offer,
14447 NodeId: wire_cst_InputType_NodeId,
14448 Url: wire_cst_InputType_Url,
14449 LnUrlPay: wire_cst_InputType_LnUrlPay,
14450 LnUrlWithdraw: wire_cst_InputType_LnUrlWithdraw,
14451 LnUrlAuth: wire_cst_InputType_LnUrlAuth,
14452 LnUrlError: wire_cst_InputType_LnUrlError,
14453 nil__: (),
14454 }
14455 #[repr(C)]
14456 #[derive(Clone, Copy)]
14457 pub struct wire_cst_InputType_BitcoinAddress {
14458 address: *mut wire_cst_bitcoin_address_data,
14459 }
14460 #[repr(C)]
14461 #[derive(Clone, Copy)]
14462 pub struct wire_cst_InputType_LiquidAddress {
14463 address: *mut wire_cst_liquid_address_data,
14464 }
14465 #[repr(C)]
14466 #[derive(Clone, Copy)]
14467 pub struct wire_cst_InputType_Bolt11 {
14468 invoice: *mut wire_cst_ln_invoice,
14469 }
14470 #[repr(C)]
14471 #[derive(Clone, Copy)]
14472 pub struct wire_cst_InputType_Bolt12Offer {
14473 offer: *mut wire_cst_ln_offer,
14474 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14475 }
14476 #[repr(C)]
14477 #[derive(Clone, Copy)]
14478 pub struct wire_cst_InputType_NodeId {
14479 node_id: *mut wire_cst_list_prim_u_8_strict,
14480 }
14481 #[repr(C)]
14482 #[derive(Clone, Copy)]
14483 pub struct wire_cst_InputType_Url {
14484 url: *mut wire_cst_list_prim_u_8_strict,
14485 }
14486 #[repr(C)]
14487 #[derive(Clone, Copy)]
14488 pub struct wire_cst_InputType_LnUrlPay {
14489 data: *mut wire_cst_ln_url_pay_request_data,
14490 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14491 }
14492 #[repr(C)]
14493 #[derive(Clone, Copy)]
14494 pub struct wire_cst_InputType_LnUrlWithdraw {
14495 data: *mut wire_cst_ln_url_withdraw_request_data,
14496 }
14497 #[repr(C)]
14498 #[derive(Clone, Copy)]
14499 pub struct wire_cst_InputType_LnUrlAuth {
14500 data: *mut wire_cst_ln_url_auth_request_data,
14501 }
14502 #[repr(C)]
14503 #[derive(Clone, Copy)]
14504 pub struct wire_cst_InputType_LnUrlError {
14505 data: *mut wire_cst_ln_url_error_data,
14506 }
14507 #[repr(C)]
14508 #[derive(Clone, Copy)]
14509 pub struct wire_cst_lightning_payment_limits_response {
14510 send: wire_cst_limits,
14511 receive: wire_cst_limits,
14512 }
14513 #[repr(C)]
14514 #[derive(Clone, Copy)]
14515 pub struct wire_cst_limits {
14516 min_sat: u64,
14517 max_sat: u64,
14518 max_zero_conf_sat: u64,
14519 }
14520 #[repr(C)]
14521 #[derive(Clone, Copy)]
14522 pub struct wire_cst_liquid_address_data {
14523 address: *mut wire_cst_list_prim_u_8_strict,
14524 network: i32,
14525 asset_id: *mut wire_cst_list_prim_u_8_strict,
14526 amount: *mut f64,
14527 amount_sat: *mut u64,
14528 label: *mut wire_cst_list_prim_u_8_strict,
14529 message: *mut wire_cst_list_prim_u_8_strict,
14530 }
14531 #[repr(C)]
14532 #[derive(Clone, Copy)]
14533 pub struct wire_cst_list_String {
14534 ptr: *mut *mut wire_cst_list_prim_u_8_strict,
14535 len: i32,
14536 }
14537 #[repr(C)]
14538 #[derive(Clone, Copy)]
14539 pub struct wire_cst_list_asset_balance {
14540 ptr: *mut wire_cst_asset_balance,
14541 len: i32,
14542 }
14543 #[repr(C)]
14544 #[derive(Clone, Copy)]
14545 pub struct wire_cst_list_asset_metadata {
14546 ptr: *mut wire_cst_asset_metadata,
14547 len: i32,
14548 }
14549 #[repr(C)]
14550 #[derive(Clone, Copy)]
14551 pub struct wire_cst_list_external_input_parser {
14552 ptr: *mut wire_cst_external_input_parser,
14553 len: i32,
14554 }
14555 #[repr(C)]
14556 #[derive(Clone, Copy)]
14557 pub struct wire_cst_list_fiat_currency {
14558 ptr: *mut wire_cst_fiat_currency,
14559 len: i32,
14560 }
14561 #[repr(C)]
14562 #[derive(Clone, Copy)]
14563 pub struct wire_cst_list_ln_offer_blinded_path {
14564 ptr: *mut wire_cst_ln_offer_blinded_path,
14565 len: i32,
14566 }
14567 #[repr(C)]
14568 #[derive(Clone, Copy)]
14569 pub struct wire_cst_list_locale_overrides {
14570 ptr: *mut wire_cst_locale_overrides,
14571 len: i32,
14572 }
14573 #[repr(C)]
14574 #[derive(Clone, Copy)]
14575 pub struct wire_cst_list_localized_name {
14576 ptr: *mut wire_cst_localized_name,
14577 len: i32,
14578 }
14579 #[repr(C)]
14580 #[derive(Clone, Copy)]
14581 pub struct wire_cst_list_payment {
14582 ptr: *mut wire_cst_payment,
14583 len: i32,
14584 }
14585 #[repr(C)]
14586 #[derive(Clone, Copy)]
14587 pub struct wire_cst_list_payment_details {
14588 tag: i32,
14589 kind: ListPaymentDetailsKind,
14590 }
14591 #[repr(C)]
14592 #[derive(Clone, Copy)]
14593 pub union ListPaymentDetailsKind {
14594 Liquid: wire_cst_ListPaymentDetails_Liquid,
14595 Bitcoin: wire_cst_ListPaymentDetails_Bitcoin,
14596 nil__: (),
14597 }
14598 #[repr(C)]
14599 #[derive(Clone, Copy)]
14600 pub struct wire_cst_ListPaymentDetails_Liquid {
14601 asset_id: *mut wire_cst_list_prim_u_8_strict,
14602 destination: *mut wire_cst_list_prim_u_8_strict,
14603 }
14604 #[repr(C)]
14605 #[derive(Clone, Copy)]
14606 pub struct wire_cst_ListPaymentDetails_Bitcoin {
14607 address: *mut wire_cst_list_prim_u_8_strict,
14608 }
14609 #[repr(C)]
14610 #[derive(Clone, Copy)]
14611 pub struct wire_cst_list_payment_state {
14612 ptr: *mut i32,
14613 len: i32,
14614 }
14615 #[repr(C)]
14616 #[derive(Clone, Copy)]
14617 pub struct wire_cst_list_payment_type {
14618 ptr: *mut i32,
14619 len: i32,
14620 }
14621 #[repr(C)]
14622 #[derive(Clone, Copy)]
14623 pub struct wire_cst_list_payments_request {
14624 filters: *mut wire_cst_list_payment_type,
14625 states: *mut wire_cst_list_payment_state,
14626 from_timestamp: *mut i64,
14627 to_timestamp: *mut i64,
14628 offset: *mut u32,
14629 limit: *mut u32,
14630 details: *mut wire_cst_list_payment_details,
14631 sort_ascending: *mut bool,
14632 }
14633 #[repr(C)]
14634 #[derive(Clone, Copy)]
14635 pub struct wire_cst_list_prim_u_8_strict {
14636 ptr: *mut u8,
14637 len: i32,
14638 }
14639 #[repr(C)]
14640 #[derive(Clone, Copy)]
14641 pub struct wire_cst_list_rate {
14642 ptr: *mut wire_cst_rate,
14643 len: i32,
14644 }
14645 #[repr(C)]
14646 #[derive(Clone, Copy)]
14647 pub struct wire_cst_list_refundable_swap {
14648 ptr: *mut wire_cst_refundable_swap,
14649 len: i32,
14650 }
14651 #[repr(C)]
14652 #[derive(Clone, Copy)]
14653 pub struct wire_cst_list_route_hint {
14654 ptr: *mut wire_cst_route_hint,
14655 len: i32,
14656 }
14657 #[repr(C)]
14658 #[derive(Clone, Copy)]
14659 pub struct wire_cst_list_route_hint_hop {
14660 ptr: *mut wire_cst_route_hint_hop,
14661 len: i32,
14662 }
14663 #[repr(C)]
14664 #[derive(Clone, Copy)]
14665 pub struct wire_cst_ln_invoice {
14666 bolt11: *mut wire_cst_list_prim_u_8_strict,
14667 network: i32,
14668 payee_pubkey: *mut wire_cst_list_prim_u_8_strict,
14669 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14670 description: *mut wire_cst_list_prim_u_8_strict,
14671 description_hash: *mut wire_cst_list_prim_u_8_strict,
14672 amount_msat: *mut u64,
14673 timestamp: u64,
14674 expiry: u64,
14675 routing_hints: *mut wire_cst_list_route_hint,
14676 payment_secret: *mut wire_cst_list_prim_u_8_strict,
14677 min_final_cltv_expiry_delta: u64,
14678 }
14679 #[repr(C)]
14680 #[derive(Clone, Copy)]
14681 pub struct wire_cst_ln_offer {
14682 offer: *mut wire_cst_list_prim_u_8_strict,
14683 chains: *mut wire_cst_list_String,
14684 min_amount: *mut wire_cst_amount,
14685 description: *mut wire_cst_list_prim_u_8_strict,
14686 absolute_expiry: *mut u64,
14687 issuer: *mut wire_cst_list_prim_u_8_strict,
14688 signing_pubkey: *mut wire_cst_list_prim_u_8_strict,
14689 paths: *mut wire_cst_list_ln_offer_blinded_path,
14690 }
14691 #[repr(C)]
14692 #[derive(Clone, Copy)]
14693 pub struct wire_cst_ln_offer_blinded_path {
14694 blinded_hops: *mut wire_cst_list_String,
14695 }
14696 #[repr(C)]
14697 #[derive(Clone, Copy)]
14698 pub struct wire_cst_ln_url_auth_error {
14699 tag: i32,
14700 kind: LnUrlAuthErrorKind,
14701 }
14702 #[repr(C)]
14703 #[derive(Clone, Copy)]
14704 pub union LnUrlAuthErrorKind {
14705 Generic: wire_cst_LnUrlAuthError_Generic,
14706 InvalidUri: wire_cst_LnUrlAuthError_InvalidUri,
14707 ServiceConnectivity: wire_cst_LnUrlAuthError_ServiceConnectivity,
14708 nil__: (),
14709 }
14710 #[repr(C)]
14711 #[derive(Clone, Copy)]
14712 pub struct wire_cst_LnUrlAuthError_Generic {
14713 err: *mut wire_cst_list_prim_u_8_strict,
14714 }
14715 #[repr(C)]
14716 #[derive(Clone, Copy)]
14717 pub struct wire_cst_LnUrlAuthError_InvalidUri {
14718 err: *mut wire_cst_list_prim_u_8_strict,
14719 }
14720 #[repr(C)]
14721 #[derive(Clone, Copy)]
14722 pub struct wire_cst_LnUrlAuthError_ServiceConnectivity {
14723 err: *mut wire_cst_list_prim_u_8_strict,
14724 }
14725 #[repr(C)]
14726 #[derive(Clone, Copy)]
14727 pub struct wire_cst_ln_url_auth_request_data {
14728 k1: *mut wire_cst_list_prim_u_8_strict,
14729 action: *mut wire_cst_list_prim_u_8_strict,
14730 domain: *mut wire_cst_list_prim_u_8_strict,
14731 url: *mut wire_cst_list_prim_u_8_strict,
14732 }
14733 #[repr(C)]
14734 #[derive(Clone, Copy)]
14735 pub struct wire_cst_ln_url_callback_status {
14736 tag: i32,
14737 kind: LnUrlCallbackStatusKind,
14738 }
14739 #[repr(C)]
14740 #[derive(Clone, Copy)]
14741 pub union LnUrlCallbackStatusKind {
14742 ErrorStatus: wire_cst_LnUrlCallbackStatus_ErrorStatus,
14743 nil__: (),
14744 }
14745 #[repr(C)]
14746 #[derive(Clone, Copy)]
14747 pub struct wire_cst_LnUrlCallbackStatus_ErrorStatus {
14748 data: *mut wire_cst_ln_url_error_data,
14749 }
14750 #[repr(C)]
14751 #[derive(Clone, Copy)]
14752 pub struct wire_cst_ln_url_error_data {
14753 reason: *mut wire_cst_list_prim_u_8_strict,
14754 }
14755 #[repr(C)]
14756 #[derive(Clone, Copy)]
14757 pub struct wire_cst_ln_url_info {
14758 ln_address: *mut wire_cst_list_prim_u_8_strict,
14759 lnurl_pay_comment: *mut wire_cst_list_prim_u_8_strict,
14760 lnurl_pay_domain: *mut wire_cst_list_prim_u_8_strict,
14761 lnurl_pay_metadata: *mut wire_cst_list_prim_u_8_strict,
14762 lnurl_pay_success_action: *mut wire_cst_success_action_processed,
14763 lnurl_pay_unprocessed_success_action: *mut wire_cst_success_action,
14764 lnurl_withdraw_endpoint: *mut wire_cst_list_prim_u_8_strict,
14765 }
14766 #[repr(C)]
14767 #[derive(Clone, Copy)]
14768 pub struct wire_cst_ln_url_pay_error {
14769 tag: i32,
14770 kind: LnUrlPayErrorKind,
14771 }
14772 #[repr(C)]
14773 #[derive(Clone, Copy)]
14774 pub union LnUrlPayErrorKind {
14775 Generic: wire_cst_LnUrlPayError_Generic,
14776 InsufficientBalance: wire_cst_LnUrlPayError_InsufficientBalance,
14777 InvalidAmount: wire_cst_LnUrlPayError_InvalidAmount,
14778 InvalidInvoice: wire_cst_LnUrlPayError_InvalidInvoice,
14779 InvalidNetwork: wire_cst_LnUrlPayError_InvalidNetwork,
14780 InvalidUri: wire_cst_LnUrlPayError_InvalidUri,
14781 InvoiceExpired: wire_cst_LnUrlPayError_InvoiceExpired,
14782 PaymentFailed: wire_cst_LnUrlPayError_PaymentFailed,
14783 PaymentTimeout: wire_cst_LnUrlPayError_PaymentTimeout,
14784 RouteNotFound: wire_cst_LnUrlPayError_RouteNotFound,
14785 RouteTooExpensive: wire_cst_LnUrlPayError_RouteTooExpensive,
14786 ServiceConnectivity: wire_cst_LnUrlPayError_ServiceConnectivity,
14787 nil__: (),
14788 }
14789 #[repr(C)]
14790 #[derive(Clone, Copy)]
14791 pub struct wire_cst_LnUrlPayError_Generic {
14792 err: *mut wire_cst_list_prim_u_8_strict,
14793 }
14794 #[repr(C)]
14795 #[derive(Clone, Copy)]
14796 pub struct wire_cst_LnUrlPayError_InsufficientBalance {
14797 err: *mut wire_cst_list_prim_u_8_strict,
14798 }
14799 #[repr(C)]
14800 #[derive(Clone, Copy)]
14801 pub struct wire_cst_LnUrlPayError_InvalidAmount {
14802 err: *mut wire_cst_list_prim_u_8_strict,
14803 }
14804 #[repr(C)]
14805 #[derive(Clone, Copy)]
14806 pub struct wire_cst_LnUrlPayError_InvalidInvoice {
14807 err: *mut wire_cst_list_prim_u_8_strict,
14808 }
14809 #[repr(C)]
14810 #[derive(Clone, Copy)]
14811 pub struct wire_cst_LnUrlPayError_InvalidNetwork {
14812 err: *mut wire_cst_list_prim_u_8_strict,
14813 }
14814 #[repr(C)]
14815 #[derive(Clone, Copy)]
14816 pub struct wire_cst_LnUrlPayError_InvalidUri {
14817 err: *mut wire_cst_list_prim_u_8_strict,
14818 }
14819 #[repr(C)]
14820 #[derive(Clone, Copy)]
14821 pub struct wire_cst_LnUrlPayError_InvoiceExpired {
14822 err: *mut wire_cst_list_prim_u_8_strict,
14823 }
14824 #[repr(C)]
14825 #[derive(Clone, Copy)]
14826 pub struct wire_cst_LnUrlPayError_PaymentFailed {
14827 err: *mut wire_cst_list_prim_u_8_strict,
14828 }
14829 #[repr(C)]
14830 #[derive(Clone, Copy)]
14831 pub struct wire_cst_LnUrlPayError_PaymentTimeout {
14832 err: *mut wire_cst_list_prim_u_8_strict,
14833 }
14834 #[repr(C)]
14835 #[derive(Clone, Copy)]
14836 pub struct wire_cst_LnUrlPayError_RouteNotFound {
14837 err: *mut wire_cst_list_prim_u_8_strict,
14838 }
14839 #[repr(C)]
14840 #[derive(Clone, Copy)]
14841 pub struct wire_cst_LnUrlPayError_RouteTooExpensive {
14842 err: *mut wire_cst_list_prim_u_8_strict,
14843 }
14844 #[repr(C)]
14845 #[derive(Clone, Copy)]
14846 pub struct wire_cst_LnUrlPayError_ServiceConnectivity {
14847 err: *mut wire_cst_list_prim_u_8_strict,
14848 }
14849 #[repr(C)]
14850 #[derive(Clone, Copy)]
14851 pub struct wire_cst_ln_url_pay_error_data {
14852 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14853 reason: *mut wire_cst_list_prim_u_8_strict,
14854 }
14855 #[repr(C)]
14856 #[derive(Clone, Copy)]
14857 pub struct wire_cst_ln_url_pay_request {
14858 prepare_response: wire_cst_prepare_ln_url_pay_response,
14859 }
14860 #[repr(C)]
14861 #[derive(Clone, Copy)]
14862 pub struct wire_cst_ln_url_pay_request_data {
14863 callback: *mut wire_cst_list_prim_u_8_strict,
14864 min_sendable: u64,
14865 max_sendable: u64,
14866 metadata_str: *mut wire_cst_list_prim_u_8_strict,
14867 comment_allowed: u16,
14868 domain: *mut wire_cst_list_prim_u_8_strict,
14869 allows_nostr: bool,
14870 nostr_pubkey: *mut wire_cst_list_prim_u_8_strict,
14871 ln_address: *mut wire_cst_list_prim_u_8_strict,
14872 }
14873 #[repr(C)]
14874 #[derive(Clone, Copy)]
14875 pub struct wire_cst_ln_url_pay_result {
14876 tag: i32,
14877 kind: LnUrlPayResultKind,
14878 }
14879 #[repr(C)]
14880 #[derive(Clone, Copy)]
14881 pub union LnUrlPayResultKind {
14882 EndpointSuccess: wire_cst_LnUrlPayResult_EndpointSuccess,
14883 EndpointError: wire_cst_LnUrlPayResult_EndpointError,
14884 PayError: wire_cst_LnUrlPayResult_PayError,
14885 nil__: (),
14886 }
14887 #[repr(C)]
14888 #[derive(Clone, Copy)]
14889 pub struct wire_cst_LnUrlPayResult_EndpointSuccess {
14890 data: *mut wire_cst_ln_url_pay_success_data,
14891 }
14892 #[repr(C)]
14893 #[derive(Clone, Copy)]
14894 pub struct wire_cst_LnUrlPayResult_EndpointError {
14895 data: *mut wire_cst_ln_url_error_data,
14896 }
14897 #[repr(C)]
14898 #[derive(Clone, Copy)]
14899 pub struct wire_cst_LnUrlPayResult_PayError {
14900 data: *mut wire_cst_ln_url_pay_error_data,
14901 }
14902 #[repr(C)]
14903 #[derive(Clone, Copy)]
14904 pub struct wire_cst_ln_url_pay_success_data {
14905 payment: wire_cst_payment,
14906 success_action: *mut wire_cst_success_action_processed,
14907 }
14908 #[repr(C)]
14909 #[derive(Clone, Copy)]
14910 pub struct wire_cst_ln_url_withdraw_error {
14911 tag: i32,
14912 kind: LnUrlWithdrawErrorKind,
14913 }
14914 #[repr(C)]
14915 #[derive(Clone, Copy)]
14916 pub union LnUrlWithdrawErrorKind {
14917 Generic: wire_cst_LnUrlWithdrawError_Generic,
14918 InvalidAmount: wire_cst_LnUrlWithdrawError_InvalidAmount,
14919 InvalidInvoice: wire_cst_LnUrlWithdrawError_InvalidInvoice,
14920 InvalidUri: wire_cst_LnUrlWithdrawError_InvalidUri,
14921 InvoiceNoRoutingHints: wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints,
14922 ServiceConnectivity: wire_cst_LnUrlWithdrawError_ServiceConnectivity,
14923 nil__: (),
14924 }
14925 #[repr(C)]
14926 #[derive(Clone, Copy)]
14927 pub struct wire_cst_LnUrlWithdrawError_Generic {
14928 err: *mut wire_cst_list_prim_u_8_strict,
14929 }
14930 #[repr(C)]
14931 #[derive(Clone, Copy)]
14932 pub struct wire_cst_LnUrlWithdrawError_InvalidAmount {
14933 err: *mut wire_cst_list_prim_u_8_strict,
14934 }
14935 #[repr(C)]
14936 #[derive(Clone, Copy)]
14937 pub struct wire_cst_LnUrlWithdrawError_InvalidInvoice {
14938 err: *mut wire_cst_list_prim_u_8_strict,
14939 }
14940 #[repr(C)]
14941 #[derive(Clone, Copy)]
14942 pub struct wire_cst_LnUrlWithdrawError_InvalidUri {
14943 err: *mut wire_cst_list_prim_u_8_strict,
14944 }
14945 #[repr(C)]
14946 #[derive(Clone, Copy)]
14947 pub struct wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints {
14948 err: *mut wire_cst_list_prim_u_8_strict,
14949 }
14950 #[repr(C)]
14951 #[derive(Clone, Copy)]
14952 pub struct wire_cst_LnUrlWithdrawError_ServiceConnectivity {
14953 err: *mut wire_cst_list_prim_u_8_strict,
14954 }
14955 #[repr(C)]
14956 #[derive(Clone, Copy)]
14957 pub struct wire_cst_ln_url_withdraw_request {
14958 data: wire_cst_ln_url_withdraw_request_data,
14959 amount_msat: u64,
14960 description: *mut wire_cst_list_prim_u_8_strict,
14961 }
14962 #[repr(C)]
14963 #[derive(Clone, Copy)]
14964 pub struct wire_cst_ln_url_withdraw_request_data {
14965 callback: *mut wire_cst_list_prim_u_8_strict,
14966 k1: *mut wire_cst_list_prim_u_8_strict,
14967 default_description: *mut wire_cst_list_prim_u_8_strict,
14968 min_withdrawable: u64,
14969 max_withdrawable: u64,
14970 }
14971 #[repr(C)]
14972 #[derive(Clone, Copy)]
14973 pub struct wire_cst_ln_url_withdraw_result {
14974 tag: i32,
14975 kind: LnUrlWithdrawResultKind,
14976 }
14977 #[repr(C)]
14978 #[derive(Clone, Copy)]
14979 pub union LnUrlWithdrawResultKind {
14980 Ok: wire_cst_LnUrlWithdrawResult_Ok,
14981 Timeout: wire_cst_LnUrlWithdrawResult_Timeout,
14982 ErrorStatus: wire_cst_LnUrlWithdrawResult_ErrorStatus,
14983 nil__: (),
14984 }
14985 #[repr(C)]
14986 #[derive(Clone, Copy)]
14987 pub struct wire_cst_LnUrlWithdrawResult_Ok {
14988 data: *mut wire_cst_ln_url_withdraw_success_data,
14989 }
14990 #[repr(C)]
14991 #[derive(Clone, Copy)]
14992 pub struct wire_cst_LnUrlWithdrawResult_Timeout {
14993 data: *mut wire_cst_ln_url_withdraw_success_data,
14994 }
14995 #[repr(C)]
14996 #[derive(Clone, Copy)]
14997 pub struct wire_cst_LnUrlWithdrawResult_ErrorStatus {
14998 data: *mut wire_cst_ln_url_error_data,
14999 }
15000 #[repr(C)]
15001 #[derive(Clone, Copy)]
15002 pub struct wire_cst_ln_url_withdraw_success_data {
15003 invoice: wire_cst_ln_invoice,
15004 }
15005 #[repr(C)]
15006 #[derive(Clone, Copy)]
15007 pub struct wire_cst_locale_overrides {
15008 locale: *mut wire_cst_list_prim_u_8_strict,
15009 spacing: *mut u32,
15010 symbol: wire_cst_symbol,
15011 }
15012 #[repr(C)]
15013 #[derive(Clone, Copy)]
15014 pub struct wire_cst_localized_name {
15015 locale: *mut wire_cst_list_prim_u_8_strict,
15016 name: *mut wire_cst_list_prim_u_8_strict,
15017 }
15018 #[repr(C)]
15019 #[derive(Clone, Copy)]
15020 pub struct wire_cst_log_entry {
15021 line: *mut wire_cst_list_prim_u_8_strict,
15022 level: *mut wire_cst_list_prim_u_8_strict,
15023 }
15024 #[repr(C)]
15025 #[derive(Clone, Copy)]
15026 pub struct wire_cst_message_success_action_data {
15027 message: *mut wire_cst_list_prim_u_8_strict,
15028 }
15029 #[repr(C)]
15030 #[derive(Clone, Copy)]
15031 pub struct wire_cst_onchain_payment_limits_response {
15032 send: wire_cst_limits,
15033 receive: wire_cst_limits,
15034 }
15035 #[repr(C)]
15036 #[derive(Clone, Copy)]
15037 pub struct wire_cst_pay_amount {
15038 tag: i32,
15039 kind: PayAmountKind,
15040 }
15041 #[repr(C)]
15042 #[derive(Clone, Copy)]
15043 pub union PayAmountKind {
15044 Bitcoin: wire_cst_PayAmount_Bitcoin,
15045 Asset: wire_cst_PayAmount_Asset,
15046 nil__: (),
15047 }
15048 #[repr(C)]
15049 #[derive(Clone, Copy)]
15050 pub struct wire_cst_PayAmount_Bitcoin {
15051 receiver_amount_sat: u64,
15052 }
15053 #[repr(C)]
15054 #[derive(Clone, Copy)]
15055 pub struct wire_cst_PayAmount_Asset {
15056 asset_id: *mut wire_cst_list_prim_u_8_strict,
15057 receiver_amount: f64,
15058 estimate_asset_fees: *mut bool,
15059 }
15060 #[repr(C)]
15061 #[derive(Clone, Copy)]
15062 pub struct wire_cst_pay_onchain_request {
15063 address: *mut wire_cst_list_prim_u_8_strict,
15064 prepare_response: wire_cst_prepare_pay_onchain_response,
15065 }
15066 #[repr(C)]
15067 #[derive(Clone, Copy)]
15068 pub struct wire_cst_payment {
15069 destination: *mut wire_cst_list_prim_u_8_strict,
15070 tx_id: *mut wire_cst_list_prim_u_8_strict,
15071 unblinding_data: *mut wire_cst_list_prim_u_8_strict,
15072 timestamp: u32,
15073 amount_sat: u64,
15074 fees_sat: u64,
15075 swapper_fees_sat: *mut u64,
15076 payment_type: i32,
15077 status: i32,
15078 details: wire_cst_payment_details,
15079 }
15080 #[repr(C)]
15081 #[derive(Clone, Copy)]
15082 pub struct wire_cst_payment_details {
15083 tag: i32,
15084 kind: PaymentDetailsKind,
15085 }
15086 #[repr(C)]
15087 #[derive(Clone, Copy)]
15088 pub union PaymentDetailsKind {
15089 Lightning: wire_cst_PaymentDetails_Lightning,
15090 Liquid: wire_cst_PaymentDetails_Liquid,
15091 Bitcoin: wire_cst_PaymentDetails_Bitcoin,
15092 nil__: (),
15093 }
15094 #[repr(C)]
15095 #[derive(Clone, Copy)]
15096 pub struct wire_cst_PaymentDetails_Lightning {
15097 swap_id: *mut wire_cst_list_prim_u_8_strict,
15098 description: *mut wire_cst_list_prim_u_8_strict,
15099 liquid_expiration_blockheight: u32,
15100 preimage: *mut wire_cst_list_prim_u_8_strict,
15101 invoice: *mut wire_cst_list_prim_u_8_strict,
15102 bolt12_offer: *mut wire_cst_list_prim_u_8_strict,
15103 payment_hash: *mut wire_cst_list_prim_u_8_strict,
15104 destination_pubkey: *mut wire_cst_list_prim_u_8_strict,
15105 lnurl_info: *mut wire_cst_ln_url_info,
15106 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15107 claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15108 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15109 refund_tx_amount_sat: *mut u64,
15110 }
15111 #[repr(C)]
15112 #[derive(Clone, Copy)]
15113 pub struct wire_cst_PaymentDetails_Liquid {
15114 destination: *mut wire_cst_list_prim_u_8_strict,
15115 description: *mut wire_cst_list_prim_u_8_strict,
15116 asset_id: *mut wire_cst_list_prim_u_8_strict,
15117 asset_info: *mut wire_cst_asset_info,
15118 lnurl_info: *mut wire_cst_ln_url_info,
15119 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15120 }
15121 #[repr(C)]
15122 #[derive(Clone, Copy)]
15123 pub struct wire_cst_PaymentDetails_Bitcoin {
15124 swap_id: *mut wire_cst_list_prim_u_8_strict,
15125 bitcoin_address: *mut wire_cst_list_prim_u_8_strict,
15126 description: *mut wire_cst_list_prim_u_8_strict,
15127 auto_accepted_fees: bool,
15128 liquid_expiration_blockheight: *mut u32,
15129 bitcoin_expiration_blockheight: *mut u32,
15130 lockup_tx_id: *mut wire_cst_list_prim_u_8_strict,
15131 claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15132 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15133 refund_tx_amount_sat: *mut u64,
15134 }
15135 #[repr(C)]
15136 #[derive(Clone, Copy)]
15137 pub struct wire_cst_payment_error {
15138 tag: i32,
15139 kind: PaymentErrorKind,
15140 }
15141 #[repr(C)]
15142 #[derive(Clone, Copy)]
15143 pub union PaymentErrorKind {
15144 AmountOutOfRange: wire_cst_PaymentError_AmountOutOfRange,
15145 AmountMissing: wire_cst_PaymentError_AmountMissing,
15146 AssetError: wire_cst_PaymentError_AssetError,
15147 InvalidNetwork: wire_cst_PaymentError_InvalidNetwork,
15148 Generic: wire_cst_PaymentError_Generic,
15149 InvalidDescription: wire_cst_PaymentError_InvalidDescription,
15150 InvalidInvoice: wire_cst_PaymentError_InvalidInvoice,
15151 ReceiveError: wire_cst_PaymentError_ReceiveError,
15152 Refunded: wire_cst_PaymentError_Refunded,
15153 SendError: wire_cst_PaymentError_SendError,
15154 SignerError: wire_cst_PaymentError_SignerError,
15155 nil__: (),
15156 }
15157 #[repr(C)]
15158 #[derive(Clone, Copy)]
15159 pub struct wire_cst_PaymentError_AmountOutOfRange {
15160 min: u64,
15161 max: u64,
15162 }
15163 #[repr(C)]
15164 #[derive(Clone, Copy)]
15165 pub struct wire_cst_PaymentError_AmountMissing {
15166 err: *mut wire_cst_list_prim_u_8_strict,
15167 }
15168 #[repr(C)]
15169 #[derive(Clone, Copy)]
15170 pub struct wire_cst_PaymentError_AssetError {
15171 err: *mut wire_cst_list_prim_u_8_strict,
15172 }
15173 #[repr(C)]
15174 #[derive(Clone, Copy)]
15175 pub struct wire_cst_PaymentError_InvalidNetwork {
15176 err: *mut wire_cst_list_prim_u_8_strict,
15177 }
15178 #[repr(C)]
15179 #[derive(Clone, Copy)]
15180 pub struct wire_cst_PaymentError_Generic {
15181 err: *mut wire_cst_list_prim_u_8_strict,
15182 }
15183 #[repr(C)]
15184 #[derive(Clone, Copy)]
15185 pub struct wire_cst_PaymentError_InvalidDescription {
15186 err: *mut wire_cst_list_prim_u_8_strict,
15187 }
15188 #[repr(C)]
15189 #[derive(Clone, Copy)]
15190 pub struct wire_cst_PaymentError_InvalidInvoice {
15191 err: *mut wire_cst_list_prim_u_8_strict,
15192 }
15193 #[repr(C)]
15194 #[derive(Clone, Copy)]
15195 pub struct wire_cst_PaymentError_ReceiveError {
15196 err: *mut wire_cst_list_prim_u_8_strict,
15197 }
15198 #[repr(C)]
15199 #[derive(Clone, Copy)]
15200 pub struct wire_cst_PaymentError_Refunded {
15201 err: *mut wire_cst_list_prim_u_8_strict,
15202 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15203 }
15204 #[repr(C)]
15205 #[derive(Clone, Copy)]
15206 pub struct wire_cst_PaymentError_SendError {
15207 err: *mut wire_cst_list_prim_u_8_strict,
15208 }
15209 #[repr(C)]
15210 #[derive(Clone, Copy)]
15211 pub struct wire_cst_PaymentError_SignerError {
15212 err: *mut wire_cst_list_prim_u_8_strict,
15213 }
15214 #[repr(C)]
15215 #[derive(Clone, Copy)]
15216 pub struct wire_cst_prepare_buy_bitcoin_request {
15217 provider: i32,
15218 amount_sat: u64,
15219 }
15220 #[repr(C)]
15221 #[derive(Clone, Copy)]
15222 pub struct wire_cst_prepare_buy_bitcoin_response {
15223 provider: i32,
15224 amount_sat: u64,
15225 fees_sat: u64,
15226 }
15227 #[repr(C)]
15228 #[derive(Clone, Copy)]
15229 pub struct wire_cst_prepare_ln_url_pay_request {
15230 data: wire_cst_ln_url_pay_request_data,
15231 amount: wire_cst_pay_amount,
15232 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15233 comment: *mut wire_cst_list_prim_u_8_strict,
15234 validate_success_action_url: *mut bool,
15235 }
15236 #[repr(C)]
15237 #[derive(Clone, Copy)]
15238 pub struct wire_cst_prepare_ln_url_pay_response {
15239 destination: wire_cst_send_destination,
15240 fees_sat: u64,
15241 data: wire_cst_ln_url_pay_request_data,
15242 amount: wire_cst_pay_amount,
15243 comment: *mut wire_cst_list_prim_u_8_strict,
15244 success_action: *mut wire_cst_success_action,
15245 }
15246 #[repr(C)]
15247 #[derive(Clone, Copy)]
15248 pub struct wire_cst_prepare_pay_onchain_request {
15249 amount: wire_cst_pay_amount,
15250 fee_rate_sat_per_vbyte: *mut u32,
15251 }
15252 #[repr(C)]
15253 #[derive(Clone, Copy)]
15254 pub struct wire_cst_prepare_pay_onchain_response {
15255 receiver_amount_sat: u64,
15256 claim_fees_sat: u64,
15257 total_fees_sat: u64,
15258 }
15259 #[repr(C)]
15260 #[derive(Clone, Copy)]
15261 pub struct wire_cst_prepare_receive_request {
15262 payment_method: i32,
15263 amount: *mut wire_cst_receive_amount,
15264 }
15265 #[repr(C)]
15266 #[derive(Clone, Copy)]
15267 pub struct wire_cst_prepare_receive_response {
15268 payment_method: i32,
15269 fees_sat: u64,
15270 amount: *mut wire_cst_receive_amount,
15271 min_payer_amount_sat: *mut u64,
15272 max_payer_amount_sat: *mut u64,
15273 swapper_feerate: *mut f64,
15274 }
15275 #[repr(C)]
15276 #[derive(Clone, Copy)]
15277 pub struct wire_cst_prepare_refund_request {
15278 swap_address: *mut wire_cst_list_prim_u_8_strict,
15279 refund_address: *mut wire_cst_list_prim_u_8_strict,
15280 fee_rate_sat_per_vbyte: u32,
15281 }
15282 #[repr(C)]
15283 #[derive(Clone, Copy)]
15284 pub struct wire_cst_prepare_refund_response {
15285 tx_vsize: u32,
15286 tx_fee_sat: u64,
15287 last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15288 }
15289 #[repr(C)]
15290 #[derive(Clone, Copy)]
15291 pub struct wire_cst_prepare_send_request {
15292 destination: *mut wire_cst_list_prim_u_8_strict,
15293 amount: *mut wire_cst_pay_amount,
15294 comment: *mut wire_cst_list_prim_u_8_strict,
15295 }
15296 #[repr(C)]
15297 #[derive(Clone, Copy)]
15298 pub struct wire_cst_prepare_send_response {
15299 destination: wire_cst_send_destination,
15300 amount: *mut wire_cst_pay_amount,
15301 fees_sat: *mut u64,
15302 estimated_asset_fees: *mut f64,
15303 }
15304 #[repr(C)]
15305 #[derive(Clone, Copy)]
15306 pub struct wire_cst_rate {
15307 coin: *mut wire_cst_list_prim_u_8_strict,
15308 value: f64,
15309 }
15310 #[repr(C)]
15311 #[derive(Clone, Copy)]
15312 pub struct wire_cst_receive_amount {
15313 tag: i32,
15314 kind: ReceiveAmountKind,
15315 }
15316 #[repr(C)]
15317 #[derive(Clone, Copy)]
15318 pub union ReceiveAmountKind {
15319 Bitcoin: wire_cst_ReceiveAmount_Bitcoin,
15320 Asset: wire_cst_ReceiveAmount_Asset,
15321 nil__: (),
15322 }
15323 #[repr(C)]
15324 #[derive(Clone, Copy)]
15325 pub struct wire_cst_ReceiveAmount_Bitcoin {
15326 payer_amount_sat: u64,
15327 }
15328 #[repr(C)]
15329 #[derive(Clone, Copy)]
15330 pub struct wire_cst_ReceiveAmount_Asset {
15331 asset_id: *mut wire_cst_list_prim_u_8_strict,
15332 payer_amount: *mut f64,
15333 }
15334 #[repr(C)]
15335 #[derive(Clone, Copy)]
15336 pub struct wire_cst_receive_payment_request {
15337 prepare_response: wire_cst_prepare_receive_response,
15338 description: *mut wire_cst_list_prim_u_8_strict,
15339 use_description_hash: *mut bool,
15340 }
15341 #[repr(C)]
15342 #[derive(Clone, Copy)]
15343 pub struct wire_cst_receive_payment_response {
15344 destination: *mut wire_cst_list_prim_u_8_strict,
15345 }
15346 #[repr(C)]
15347 #[derive(Clone, Copy)]
15348 pub struct wire_cst_recommended_fees {
15349 fastest_fee: u64,
15350 half_hour_fee: u64,
15351 hour_fee: u64,
15352 economy_fee: u64,
15353 minimum_fee: u64,
15354 }
15355 #[repr(C)]
15356 #[derive(Clone, Copy)]
15357 pub struct wire_cst_refund_request {
15358 swap_address: *mut wire_cst_list_prim_u_8_strict,
15359 refund_address: *mut wire_cst_list_prim_u_8_strict,
15360 fee_rate_sat_per_vbyte: u32,
15361 }
15362 #[repr(C)]
15363 #[derive(Clone, Copy)]
15364 pub struct wire_cst_refund_response {
15365 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15366 }
15367 #[repr(C)]
15368 #[derive(Clone, Copy)]
15369 pub struct wire_cst_refundable_swap {
15370 swap_address: *mut wire_cst_list_prim_u_8_strict,
15371 timestamp: u32,
15372 amount_sat: u64,
15373 last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15374 }
15375 #[repr(C)]
15376 #[derive(Clone, Copy)]
15377 pub struct wire_cst_restore_request {
15378 backup_path: *mut wire_cst_list_prim_u_8_strict,
15379 }
15380 #[repr(C)]
15381 #[derive(Clone, Copy)]
15382 pub struct wire_cst_route_hint {
15383 hops: *mut wire_cst_list_route_hint_hop,
15384 }
15385 #[repr(C)]
15386 #[derive(Clone, Copy)]
15387 pub struct wire_cst_route_hint_hop {
15388 src_node_id: *mut wire_cst_list_prim_u_8_strict,
15389 short_channel_id: *mut wire_cst_list_prim_u_8_strict,
15390 fees_base_msat: u32,
15391 fees_proportional_millionths: u32,
15392 cltv_expiry_delta: u64,
15393 htlc_minimum_msat: *mut u64,
15394 htlc_maximum_msat: *mut u64,
15395 }
15396 #[repr(C)]
15397 #[derive(Clone, Copy)]
15398 pub struct wire_cst_sdk_error {
15399 tag: i32,
15400 kind: SdkErrorKind,
15401 }
15402 #[repr(C)]
15403 #[derive(Clone, Copy)]
15404 pub union SdkErrorKind {
15405 Generic: wire_cst_SdkError_Generic,
15406 ServiceConnectivity: wire_cst_SdkError_ServiceConnectivity,
15407 nil__: (),
15408 }
15409 #[repr(C)]
15410 #[derive(Clone, Copy)]
15411 pub struct wire_cst_SdkError_Generic {
15412 err: *mut wire_cst_list_prim_u_8_strict,
15413 }
15414 #[repr(C)]
15415 #[derive(Clone, Copy)]
15416 pub struct wire_cst_SdkError_ServiceConnectivity {
15417 err: *mut wire_cst_list_prim_u_8_strict,
15418 }
15419 #[repr(C)]
15420 #[derive(Clone, Copy)]
15421 pub struct wire_cst_sdk_event {
15422 tag: i32,
15423 kind: SdkEventKind,
15424 }
15425 #[repr(C)]
15426 #[derive(Clone, Copy)]
15427 pub union SdkEventKind {
15428 PaymentFailed: wire_cst_SdkEvent_PaymentFailed,
15429 PaymentPending: wire_cst_SdkEvent_PaymentPending,
15430 PaymentRefundable: wire_cst_SdkEvent_PaymentRefundable,
15431 PaymentRefunded: wire_cst_SdkEvent_PaymentRefunded,
15432 PaymentRefundPending: wire_cst_SdkEvent_PaymentRefundPending,
15433 PaymentSucceeded: wire_cst_SdkEvent_PaymentSucceeded,
15434 PaymentWaitingConfirmation: wire_cst_SdkEvent_PaymentWaitingConfirmation,
15435 PaymentWaitingFeeAcceptance: wire_cst_SdkEvent_PaymentWaitingFeeAcceptance,
15436 DataSynced: wire_cst_SdkEvent_DataSynced,
15437 nil__: (),
15438 }
15439 #[repr(C)]
15440 #[derive(Clone, Copy)]
15441 pub struct wire_cst_SdkEvent_PaymentFailed {
15442 details: *mut wire_cst_payment,
15443 }
15444 #[repr(C)]
15445 #[derive(Clone, Copy)]
15446 pub struct wire_cst_SdkEvent_PaymentPending {
15447 details: *mut wire_cst_payment,
15448 }
15449 #[repr(C)]
15450 #[derive(Clone, Copy)]
15451 pub struct wire_cst_SdkEvent_PaymentRefundable {
15452 details: *mut wire_cst_payment,
15453 }
15454 #[repr(C)]
15455 #[derive(Clone, Copy)]
15456 pub struct wire_cst_SdkEvent_PaymentRefunded {
15457 details: *mut wire_cst_payment,
15458 }
15459 #[repr(C)]
15460 #[derive(Clone, Copy)]
15461 pub struct wire_cst_SdkEvent_PaymentRefundPending {
15462 details: *mut wire_cst_payment,
15463 }
15464 #[repr(C)]
15465 #[derive(Clone, Copy)]
15466 pub struct wire_cst_SdkEvent_PaymentSucceeded {
15467 details: *mut wire_cst_payment,
15468 }
15469 #[repr(C)]
15470 #[derive(Clone, Copy)]
15471 pub struct wire_cst_SdkEvent_PaymentWaitingConfirmation {
15472 details: *mut wire_cst_payment,
15473 }
15474 #[repr(C)]
15475 #[derive(Clone, Copy)]
15476 pub struct wire_cst_SdkEvent_PaymentWaitingFeeAcceptance {
15477 details: *mut wire_cst_payment,
15478 }
15479 #[repr(C)]
15480 #[derive(Clone, Copy)]
15481 pub struct wire_cst_SdkEvent_DataSynced {
15482 did_pull_new_records: bool,
15483 }
15484 #[repr(C)]
15485 #[derive(Clone, Copy)]
15486 pub struct wire_cst_send_destination {
15487 tag: i32,
15488 kind: SendDestinationKind,
15489 }
15490 #[repr(C)]
15491 #[derive(Clone, Copy)]
15492 pub union SendDestinationKind {
15493 LiquidAddress: wire_cst_SendDestination_LiquidAddress,
15494 Bolt11: wire_cst_SendDestination_Bolt11,
15495 Bolt12: wire_cst_SendDestination_Bolt12,
15496 nil__: (),
15497 }
15498 #[repr(C)]
15499 #[derive(Clone, Copy)]
15500 pub struct wire_cst_SendDestination_LiquidAddress {
15501 address_data: *mut wire_cst_liquid_address_data,
15502 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15503 }
15504 #[repr(C)]
15505 #[derive(Clone, Copy)]
15506 pub struct wire_cst_SendDestination_Bolt11 {
15507 invoice: *mut wire_cst_ln_invoice,
15508 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15509 }
15510 #[repr(C)]
15511 #[derive(Clone, Copy)]
15512 pub struct wire_cst_SendDestination_Bolt12 {
15513 offer: *mut wire_cst_ln_offer,
15514 receiver_amount_sat: u64,
15515 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15516 payer_note: *mut wire_cst_list_prim_u_8_strict,
15517 }
15518 #[repr(C)]
15519 #[derive(Clone, Copy)]
15520 pub struct wire_cst_send_payment_request {
15521 prepare_response: wire_cst_prepare_send_response,
15522 use_asset_fees: *mut bool,
15523 }
15524 #[repr(C)]
15525 #[derive(Clone, Copy)]
15526 pub struct wire_cst_send_payment_response {
15527 payment: wire_cst_payment,
15528 }
15529 #[repr(C)]
15530 #[derive(Clone, Copy)]
15531 pub struct wire_cst_sign_message_request {
15532 message: *mut wire_cst_list_prim_u_8_strict,
15533 }
15534 #[repr(C)]
15535 #[derive(Clone, Copy)]
15536 pub struct wire_cst_sign_message_response {
15537 signature: *mut wire_cst_list_prim_u_8_strict,
15538 }
15539 #[repr(C)]
15540 #[derive(Clone, Copy)]
15541 pub struct wire_cst_success_action {
15542 tag: i32,
15543 kind: SuccessActionKind,
15544 }
15545 #[repr(C)]
15546 #[derive(Clone, Copy)]
15547 pub union SuccessActionKind {
15548 Aes: wire_cst_SuccessAction_Aes,
15549 Message: wire_cst_SuccessAction_Message,
15550 Url: wire_cst_SuccessAction_Url,
15551 nil__: (),
15552 }
15553 #[repr(C)]
15554 #[derive(Clone, Copy)]
15555 pub struct wire_cst_SuccessAction_Aes {
15556 data: *mut wire_cst_aes_success_action_data,
15557 }
15558 #[repr(C)]
15559 #[derive(Clone, Copy)]
15560 pub struct wire_cst_SuccessAction_Message {
15561 data: *mut wire_cst_message_success_action_data,
15562 }
15563 #[repr(C)]
15564 #[derive(Clone, Copy)]
15565 pub struct wire_cst_SuccessAction_Url {
15566 data: *mut wire_cst_url_success_action_data,
15567 }
15568 #[repr(C)]
15569 #[derive(Clone, Copy)]
15570 pub struct wire_cst_success_action_processed {
15571 tag: i32,
15572 kind: SuccessActionProcessedKind,
15573 }
15574 #[repr(C)]
15575 #[derive(Clone, Copy)]
15576 pub union SuccessActionProcessedKind {
15577 Aes: wire_cst_SuccessActionProcessed_Aes,
15578 Message: wire_cst_SuccessActionProcessed_Message,
15579 Url: wire_cst_SuccessActionProcessed_Url,
15580 nil__: (),
15581 }
15582 #[repr(C)]
15583 #[derive(Clone, Copy)]
15584 pub struct wire_cst_SuccessActionProcessed_Aes {
15585 result: *mut wire_cst_aes_success_action_data_result,
15586 }
15587 #[repr(C)]
15588 #[derive(Clone, Copy)]
15589 pub struct wire_cst_SuccessActionProcessed_Message {
15590 data: *mut wire_cst_message_success_action_data,
15591 }
15592 #[repr(C)]
15593 #[derive(Clone, Copy)]
15594 pub struct wire_cst_SuccessActionProcessed_Url {
15595 data: *mut wire_cst_url_success_action_data,
15596 }
15597 #[repr(C)]
15598 #[derive(Clone, Copy)]
15599 pub struct wire_cst_symbol {
15600 grapheme: *mut wire_cst_list_prim_u_8_strict,
15601 template: *mut wire_cst_list_prim_u_8_strict,
15602 rtl: *mut bool,
15603 position: *mut u32,
15604 }
15605 #[repr(C)]
15606 #[derive(Clone, Copy)]
15607 pub struct wire_cst_url_success_action_data {
15608 description: *mut wire_cst_list_prim_u_8_strict,
15609 url: *mut wire_cst_list_prim_u_8_strict,
15610 matches_callback_domain: bool,
15611 }
15612 #[repr(C)]
15613 #[derive(Clone, Copy)]
15614 pub struct wire_cst_wallet_info {
15615 balance_sat: u64,
15616 pending_send_sat: u64,
15617 pending_receive_sat: u64,
15618 fingerprint: *mut wire_cst_list_prim_u_8_strict,
15619 pubkey: *mut wire_cst_list_prim_u_8_strict,
15620 asset_balances: *mut wire_cst_list_asset_balance,
15621 }
15622}
15623#[cfg(not(target_family = "wasm"))]
15624pub use io::*;