1#![allow(
5 non_camel_case_types,
6 unused,
7 non_snake_case,
8 clippy::needless_return,
9 clippy::redundant_closure_call,
10 clippy::redundant_closure,
11 clippy::useless_conversion,
12 clippy::unit_arg,
13 clippy::unused_unit,
14 clippy::double_parens,
15 clippy::let_and_return,
16 clippy::too_many_arguments,
17 clippy::match_single_binding,
18 clippy::clone_on_copy,
19 clippy::let_unit_value,
20 clippy::deref_addrof,
21 clippy::explicit_auto_deref,
22 clippy::borrow_deref_ref,
23 clippy::needless_borrow
24)]
25
26use crate::bindings::*;
29use crate::model::EventListener;
30use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
31use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
32use flutter_rust_bridge::{Handler, IntoIntoDart};
33
34flutter_rust_bridge::frb_generated_boilerplate!(
37 default_stream_sink_codec = DcoCodec,
38 default_rust_opaque = RustOpaqueNom,
39 default_rust_auto_opaque = RustAutoOpaqueNom,
40);
41pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.9.0";
42pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 464449310;
43
44flutter_rust_bridge::frb_generated_default_handler!();
47
48fn wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(
51 port_: flutter_rust_bridge::for_generated::MessagePort,
52 that: impl CstDecode<
53 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
54 >,
55 req: impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>,
56) {
57 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
58 flutter_rust_bridge::for_generated::TaskInfo {
59 debug_name: "BindingLiquidSdk_accept_payment_proposed_fees",
60 port: Some(port_),
61 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
62 },
63 move || {
64 let api_that = that.cst_decode();
65 let api_req = req.cst_decode();
66 move |context| async move {
67 transform_result_dco::<_, _, crate::error::PaymentError>(
68 (move || async move {
69 let mut api_that_guard = None;
70 let decode_indices_ =
71 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
72 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
73 &api_that, 0, false,
74 )],
75 );
76 for i in decode_indices_ {
77 match i {
78 0 => {
79 api_that_guard =
80 Some(api_that.lockable_decode_async_ref().await)
81 }
82 _ => unreachable!(),
83 }
84 }
85 let api_that_guard = api_that_guard.unwrap();
86 let output_ok =
87 crate::bindings::BindingLiquidSdk::accept_payment_proposed_fees(
88 &*api_that_guard,
89 api_req,
90 )
91 .await?;
92 Ok(output_ok)
93 })()
94 .await,
95 )
96 }
97 },
98 )
99}
100fn wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(
101 port_: flutter_rust_bridge::for_generated::MessagePort,
102 that: impl CstDecode<
103 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
104 >,
105 listener: impl CstDecode<
106 StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>,
107 >,
108) {
109 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
110 flutter_rust_bridge::for_generated::TaskInfo {
111 debug_name: "BindingLiquidSdk_add_event_listener",
112 port: Some(port_),
113 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
114 },
115 move || {
116 let api_that = that.cst_decode();
117 let api_listener = listener.cst_decode();
118 move |context| async move {
119 transform_result_dco::<_, _, crate::error::SdkError>(
120 (move || async move {
121 let mut api_that_guard = None;
122 let decode_indices_ =
123 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
124 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
125 &api_that, 0, false,
126 )],
127 );
128 for i in decode_indices_ {
129 match i {
130 0 => {
131 api_that_guard =
132 Some(api_that.lockable_decode_async_ref().await)
133 }
134 _ => unreachable!(),
135 }
136 }
137 let api_that_guard = api_that_guard.unwrap();
138 let output_ok = crate::bindings::BindingLiquidSdk::add_event_listener(
139 &*api_that_guard,
140 api_listener,
141 )
142 .await?;
143 Ok(output_ok)
144 })()
145 .await,
146 )
147 }
148 },
149 )
150}
151fn wire__crate__bindings__BindingLiquidSdk_backup_impl(
152 that: impl CstDecode<
153 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
154 >,
155 req: impl CstDecode<crate::model::BackupRequest>,
156) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
157 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
158 flutter_rust_bridge::for_generated::TaskInfo {
159 debug_name: "BindingLiquidSdk_backup",
160 port: None,
161 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
162 },
163 move || {
164 let api_that = that.cst_decode();
165 let api_req = req.cst_decode();
166 transform_result_dco::<_, _, crate::error::SdkError>((move || {
167 let mut api_that_guard = None;
168 let decode_indices_ =
169 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
170 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
171 &api_that, 0, false,
172 ),
173 ]);
174 for i in decode_indices_ {
175 match i {
176 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
177 _ => unreachable!(),
178 }
179 }
180 let api_that_guard = api_that_guard.unwrap();
181 let output_ok =
182 crate::bindings::BindingLiquidSdk::backup(&*api_that_guard, api_req)?;
183 Ok(output_ok)
184 })())
185 },
186 )
187}
188fn wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(
189 port_: flutter_rust_bridge::for_generated::MessagePort,
190 that: impl CstDecode<
191 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
192 >,
193 req: impl CstDecode<crate::model::BuyBitcoinRequest>,
194) {
195 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
196 flutter_rust_bridge::for_generated::TaskInfo {
197 debug_name: "BindingLiquidSdk_buy_bitcoin",
198 port: Some(port_),
199 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
200 },
201 move || {
202 let api_that = that.cst_decode();
203 let api_req = req.cst_decode();
204 move |context| async move {
205 transform_result_dco::<_, _, crate::error::PaymentError>(
206 (move || async move {
207 let mut api_that_guard = None;
208 let decode_indices_ =
209 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
210 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
211 &api_that, 0, false,
212 )],
213 );
214 for i in decode_indices_ {
215 match i {
216 0 => {
217 api_that_guard =
218 Some(api_that.lockable_decode_async_ref().await)
219 }
220 _ => unreachable!(),
221 }
222 }
223 let api_that_guard = api_that_guard.unwrap();
224 let output_ok = crate::bindings::BindingLiquidSdk::buy_bitcoin(
225 &*api_that_guard,
226 api_req,
227 )
228 .await?;
229 Ok(output_ok)
230 })()
231 .await,
232 )
233 }
234 },
235 )
236}
237fn wire__crate__bindings__BindingLiquidSdk_check_message_impl(
238 that: impl CstDecode<
239 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
240 >,
241 req: impl CstDecode<crate::model::CheckMessageRequest>,
242) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
243 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
244 flutter_rust_bridge::for_generated::TaskInfo {
245 debug_name: "BindingLiquidSdk_check_message",
246 port: None,
247 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
248 },
249 move || {
250 let api_that = that.cst_decode();
251 let api_req = req.cst_decode();
252 transform_result_dco::<_, _, crate::error::SdkError>((move || {
253 let mut api_that_guard = None;
254 let decode_indices_ =
255 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
256 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
257 &api_that, 0, false,
258 ),
259 ]);
260 for i in decode_indices_ {
261 match i {
262 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
263 _ => unreachable!(),
264 }
265 }
266 let api_that_guard = api_that_guard.unwrap();
267 let output_ok =
268 crate::bindings::BindingLiquidSdk::check_message(&*api_that_guard, api_req)?;
269 Ok(output_ok)
270 })())
271 },
272 )
273}
274fn wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(
275 port_: flutter_rust_bridge::for_generated::MessagePort,
276 that: impl CstDecode<
277 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
278 >,
279 req: impl CstDecode<crate::model::CreateBolt12InvoiceRequest>,
280) {
281 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
282 flutter_rust_bridge::for_generated::TaskInfo {
283 debug_name: "BindingLiquidSdk_create_bolt12_invoice",
284 port: Some(port_),
285 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
286 },
287 move || {
288 let api_that = that.cst_decode();
289 let api_req = req.cst_decode();
290 move |context| async move {
291 transform_result_dco::<_, _, crate::error::PaymentError>(
292 (move || async move {
293 let mut api_that_guard = None;
294 let decode_indices_ =
295 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
296 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
297 &api_that, 0, false,
298 )],
299 );
300 for i in decode_indices_ {
301 match i {
302 0 => {
303 api_that_guard =
304 Some(api_that.lockable_decode_async_ref().await)
305 }
306 _ => unreachable!(),
307 }
308 }
309 let api_that_guard = api_that_guard.unwrap();
310 let output_ok = crate::bindings::BindingLiquidSdk::create_bolt12_invoice(
311 &*api_that_guard,
312 api_req,
313 )
314 .await?;
315 Ok(output_ok)
316 })()
317 .await,
318 )
319 }
320 },
321 )
322}
323fn wire__crate__bindings__BindingLiquidSdk_disconnect_impl(
324 port_: flutter_rust_bridge::for_generated::MessagePort,
325 that: impl CstDecode<
326 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
327 >,
328) {
329 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
330 flutter_rust_bridge::for_generated::TaskInfo {
331 debug_name: "BindingLiquidSdk_disconnect",
332 port: Some(port_),
333 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
334 },
335 move || {
336 let api_that = that.cst_decode();
337 move |context| async move {
338 transform_result_dco::<_, _, crate::error::SdkError>(
339 (move || async move {
340 let mut api_that_guard = None;
341 let decode_indices_ =
342 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
343 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
344 &api_that, 0, false,
345 )],
346 );
347 for i in decode_indices_ {
348 match i {
349 0 => {
350 api_that_guard =
351 Some(api_that.lockable_decode_async_ref().await)
352 }
353 _ => unreachable!(),
354 }
355 }
356 let api_that_guard = api_that_guard.unwrap();
357 let output_ok =
358 crate::bindings::BindingLiquidSdk::disconnect(&*api_that_guard).await?;
359 Ok(output_ok)
360 })()
361 .await,
362 )
363 }
364 },
365 )
366}
367fn wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(
368 that: impl CstDecode<
369 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
370 >,
371) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
372 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
373 flutter_rust_bridge::for_generated::TaskInfo {
374 debug_name: "BindingLiquidSdk_empty_wallet_cache",
375 port: None,
376 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
377 },
378 move || {
379 let api_that = that.cst_decode();
380 transform_result_dco::<_, _, crate::error::SdkError>((move || {
381 let mut api_that_guard = None;
382 let decode_indices_ =
383 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
384 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
385 &api_that, 0, false,
386 ),
387 ]);
388 for i in decode_indices_ {
389 match i {
390 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
391 _ => unreachable!(),
392 }
393 }
394 let api_that_guard = api_that_guard.unwrap();
395 let output_ok =
396 crate::bindings::BindingLiquidSdk::empty_wallet_cache(&*api_that_guard)?;
397 Ok(output_ok)
398 })())
399 },
400 )
401}
402fn wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(
403 port_: flutter_rust_bridge::for_generated::MessagePort,
404 that: impl CstDecode<
405 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
406 >,
407) {
408 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
409 flutter_rust_bridge::for_generated::TaskInfo {
410 debug_name: "BindingLiquidSdk_fetch_fiat_rates",
411 port: Some(port_),
412 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
413 },
414 move || {
415 let api_that = that.cst_decode();
416 move |context| async move {
417 transform_result_dco::<_, _, crate::error::SdkError>(
418 (move || async move {
419 let mut api_that_guard = None;
420 let decode_indices_ =
421 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
422 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
423 &api_that, 0, false,
424 )],
425 );
426 for i in decode_indices_ {
427 match i {
428 0 => {
429 api_that_guard =
430 Some(api_that.lockable_decode_async_ref().await)
431 }
432 _ => unreachable!(),
433 }
434 }
435 let api_that_guard = api_that_guard.unwrap();
436 let output_ok =
437 crate::bindings::BindingLiquidSdk::fetch_fiat_rates(&*api_that_guard)
438 .await?;
439 Ok(output_ok)
440 })()
441 .await,
442 )
443 }
444 },
445 )
446}
447fn wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(
448 port_: flutter_rust_bridge::for_generated::MessagePort,
449 that: impl CstDecode<
450 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
451 >,
452) {
453 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
454 flutter_rust_bridge::for_generated::TaskInfo {
455 debug_name: "BindingLiquidSdk_fetch_lightning_limits",
456 port: Some(port_),
457 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
458 },
459 move || {
460 let api_that = that.cst_decode();
461 move |context| async move {
462 transform_result_dco::<_, _, crate::error::PaymentError>(
463 (move || async move {
464 let mut api_that_guard = None;
465 let decode_indices_ =
466 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
467 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
468 &api_that, 0, false,
469 )],
470 );
471 for i in decode_indices_ {
472 match i {
473 0 => {
474 api_that_guard =
475 Some(api_that.lockable_decode_async_ref().await)
476 }
477 _ => unreachable!(),
478 }
479 }
480 let api_that_guard = api_that_guard.unwrap();
481 let output_ok = crate::bindings::BindingLiquidSdk::fetch_lightning_limits(
482 &*api_that_guard,
483 )
484 .await?;
485 Ok(output_ok)
486 })()
487 .await,
488 )
489 }
490 },
491 )
492}
493fn wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(
494 port_: flutter_rust_bridge::for_generated::MessagePort,
495 that: impl CstDecode<
496 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
497 >,
498) {
499 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
500 flutter_rust_bridge::for_generated::TaskInfo {
501 debug_name: "BindingLiquidSdk_fetch_onchain_limits",
502 port: Some(port_),
503 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
504 },
505 move || {
506 let api_that = that.cst_decode();
507 move |context| async move {
508 transform_result_dco::<_, _, crate::error::PaymentError>(
509 (move || async move {
510 let mut api_that_guard = None;
511 let decode_indices_ =
512 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
513 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
514 &api_that, 0, false,
515 )],
516 );
517 for i in decode_indices_ {
518 match i {
519 0 => {
520 api_that_guard =
521 Some(api_that.lockable_decode_async_ref().await)
522 }
523 _ => unreachable!(),
524 }
525 }
526 let api_that_guard = api_that_guard.unwrap();
527 let output_ok = crate::bindings::BindingLiquidSdk::fetch_onchain_limits(
528 &*api_that_guard,
529 )
530 .await?;
531 Ok(output_ok)
532 })()
533 .await,
534 )
535 }
536 },
537 )
538}
539fn wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(
540 port_: flutter_rust_bridge::for_generated::MessagePort,
541 that: impl CstDecode<
542 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
543 >,
544 req: impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>,
545) {
546 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
547 flutter_rust_bridge::for_generated::TaskInfo {
548 debug_name: "BindingLiquidSdk_fetch_payment_proposed_fees",
549 port: Some(port_),
550 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
551 },
552 move || {
553 let api_that = that.cst_decode();
554 let api_req = req.cst_decode();
555 move |context| async move {
556 transform_result_dco::<_, _, crate::error::SdkError>(
557 (move || async move {
558 let mut api_that_guard = None;
559 let decode_indices_ =
560 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
561 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
562 &api_that, 0, false,
563 )],
564 );
565 for i in decode_indices_ {
566 match i {
567 0 => {
568 api_that_guard =
569 Some(api_that.lockable_decode_async_ref().await)
570 }
571 _ => unreachable!(),
572 }
573 }
574 let api_that_guard = api_that_guard.unwrap();
575 let output_ok =
576 crate::bindings::BindingLiquidSdk::fetch_payment_proposed_fees(
577 &*api_that_guard,
578 api_req,
579 )
580 .await?;
581 Ok(output_ok)
582 })()
583 .await,
584 )
585 }
586 },
587 )
588}
589fn wire__crate__bindings__BindingLiquidSdk_get_info_impl(
590 port_: flutter_rust_bridge::for_generated::MessagePort,
591 that: impl CstDecode<
592 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
593 >,
594) {
595 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
596 flutter_rust_bridge::for_generated::TaskInfo {
597 debug_name: "BindingLiquidSdk_get_info",
598 port: Some(port_),
599 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
600 },
601 move || {
602 let api_that = that.cst_decode();
603 move |context| async move {
604 transform_result_dco::<_, _, crate::error::SdkError>(
605 (move || async move {
606 let mut api_that_guard = None;
607 let decode_indices_ =
608 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
609 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
610 &api_that, 0, false,
611 )],
612 );
613 for i in decode_indices_ {
614 match i {
615 0 => {
616 api_that_guard =
617 Some(api_that.lockable_decode_async_ref().await)
618 }
619 _ => unreachable!(),
620 }
621 }
622 let api_that_guard = api_that_guard.unwrap();
623 let output_ok =
624 crate::bindings::BindingLiquidSdk::get_info(&*api_that_guard).await?;
625 Ok(output_ok)
626 })()
627 .await,
628 )
629 }
630 },
631 )
632}
633fn wire__crate__bindings__BindingLiquidSdk_get_payment_impl(
634 port_: flutter_rust_bridge::for_generated::MessagePort,
635 that: impl CstDecode<
636 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
637 >,
638 req: impl CstDecode<crate::model::GetPaymentRequest>,
639) {
640 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
641 flutter_rust_bridge::for_generated::TaskInfo {
642 debug_name: "BindingLiquidSdk_get_payment",
643 port: Some(port_),
644 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
645 },
646 move || {
647 let api_that = that.cst_decode();
648 let api_req = req.cst_decode();
649 move |context| async move {
650 transform_result_dco::<_, _, crate::error::PaymentError>(
651 (move || async move {
652 let mut api_that_guard = None;
653 let decode_indices_ =
654 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
655 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
656 &api_that, 0, false,
657 )],
658 );
659 for i in decode_indices_ {
660 match i {
661 0 => {
662 api_that_guard =
663 Some(api_that.lockable_decode_async_ref().await)
664 }
665 _ => unreachable!(),
666 }
667 }
668 let api_that_guard = api_that_guard.unwrap();
669 let output_ok = crate::bindings::BindingLiquidSdk::get_payment(
670 &*api_that_guard,
671 api_req,
672 )
673 .await?;
674 Ok(output_ok)
675 })()
676 .await,
677 )
678 }
679 },
680 )
681}
682fn wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(
683 port_: flutter_rust_bridge::for_generated::MessagePort,
684 that: impl CstDecode<
685 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
686 >,
687) {
688 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
689 flutter_rust_bridge::for_generated::TaskInfo {
690 debug_name: "BindingLiquidSdk_list_fiat_currencies",
691 port: Some(port_),
692 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
693 },
694 move || {
695 let api_that = that.cst_decode();
696 move |context| async move {
697 transform_result_dco::<_, _, crate::error::SdkError>(
698 (move || async move {
699 let mut api_that_guard = None;
700 let decode_indices_ =
701 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
702 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
703 &api_that, 0, false,
704 )],
705 );
706 for i in decode_indices_ {
707 match i {
708 0 => {
709 api_that_guard =
710 Some(api_that.lockable_decode_async_ref().await)
711 }
712 _ => unreachable!(),
713 }
714 }
715 let api_that_guard = api_that_guard.unwrap();
716 let output_ok = crate::bindings::BindingLiquidSdk::list_fiat_currencies(
717 &*api_that_guard,
718 )
719 .await?;
720 Ok(output_ok)
721 })()
722 .await,
723 )
724 }
725 },
726 )
727}
728fn wire__crate__bindings__BindingLiquidSdk_list_payments_impl(
729 port_: flutter_rust_bridge::for_generated::MessagePort,
730 that: impl CstDecode<
731 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
732 >,
733 req: impl CstDecode<crate::model::ListPaymentsRequest>,
734) {
735 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
736 flutter_rust_bridge::for_generated::TaskInfo {
737 debug_name: "BindingLiquidSdk_list_payments",
738 port: Some(port_),
739 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
740 },
741 move || {
742 let api_that = that.cst_decode();
743 let api_req = req.cst_decode();
744 move |context| async move {
745 transform_result_dco::<_, _, crate::error::PaymentError>(
746 (move || async move {
747 let mut api_that_guard = None;
748 let decode_indices_ =
749 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
750 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
751 &api_that, 0, false,
752 )],
753 );
754 for i in decode_indices_ {
755 match i {
756 0 => {
757 api_that_guard =
758 Some(api_that.lockable_decode_async_ref().await)
759 }
760 _ => unreachable!(),
761 }
762 }
763 let api_that_guard = api_that_guard.unwrap();
764 let output_ok = crate::bindings::BindingLiquidSdk::list_payments(
765 &*api_that_guard,
766 api_req,
767 )
768 .await?;
769 Ok(output_ok)
770 })()
771 .await,
772 )
773 }
774 },
775 )
776}
777fn wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(
778 port_: flutter_rust_bridge::for_generated::MessagePort,
779 that: impl CstDecode<
780 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
781 >,
782) {
783 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
784 flutter_rust_bridge::for_generated::TaskInfo {
785 debug_name: "BindingLiquidSdk_list_refundables",
786 port: Some(port_),
787 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
788 },
789 move || {
790 let api_that = that.cst_decode();
791 move |context| async move {
792 transform_result_dco::<_, _, crate::error::SdkError>(
793 (move || async move {
794 let mut api_that_guard = None;
795 let decode_indices_ =
796 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
797 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
798 &api_that, 0, false,
799 )],
800 );
801 for i in decode_indices_ {
802 match i {
803 0 => {
804 api_that_guard =
805 Some(api_that.lockable_decode_async_ref().await)
806 }
807 _ => unreachable!(),
808 }
809 }
810 let api_that_guard = api_that_guard.unwrap();
811 let output_ok =
812 crate::bindings::BindingLiquidSdk::list_refundables(&*api_that_guard)
813 .await?;
814 Ok(output_ok)
815 })()
816 .await,
817 )
818 }
819 },
820 )
821}
822fn wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(
823 port_: flutter_rust_bridge::for_generated::MessagePort,
824 that: impl CstDecode<
825 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
826 >,
827 req_data: impl CstDecode<crate::bindings::LnUrlAuthRequestData>,
828) {
829 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
830 flutter_rust_bridge::for_generated::TaskInfo {
831 debug_name: "BindingLiquidSdk_lnurl_auth",
832 port: Some(port_),
833 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
834 },
835 move || {
836 let api_that = that.cst_decode();
837 let api_req_data = req_data.cst_decode();
838 move |context| async move {
839 transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlAuthError>(
840 (move || async move {
841 let mut api_that_guard = None;
842 let decode_indices_ =
843 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
844 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
845 &api_that, 0, false,
846 )],
847 );
848 for i in decode_indices_ {
849 match i {
850 0 => {
851 api_that_guard =
852 Some(api_that.lockable_decode_async_ref().await)
853 }
854 _ => unreachable!(),
855 }
856 }
857 let api_that_guard = api_that_guard.unwrap();
858 let output_ok = crate::bindings::BindingLiquidSdk::lnurl_auth(
859 &*api_that_guard,
860 api_req_data,
861 )
862 .await?;
863 Ok(output_ok)
864 })()
865 .await,
866 )
867 }
868 },
869 )
870}
871fn wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(
872 port_: flutter_rust_bridge::for_generated::MessagePort,
873 that: impl CstDecode<
874 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
875 >,
876 req: impl CstDecode<crate::model::LnUrlPayRequest>,
877) {
878 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
879 flutter_rust_bridge::for_generated::TaskInfo {
880 debug_name: "BindingLiquidSdk_lnurl_pay",
881 port: Some(port_),
882 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
883 },
884 move || {
885 let api_that = that.cst_decode();
886 let api_req = req.cst_decode();
887 move |context| async move {
888 transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlPayError>(
889 (move || async move {
890 let mut api_that_guard = None;
891 let decode_indices_ =
892 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
893 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
894 &api_that, 0, false,
895 )],
896 );
897 for i in decode_indices_ {
898 match i {
899 0 => {
900 api_that_guard =
901 Some(api_that.lockable_decode_async_ref().await)
902 }
903 _ => unreachable!(),
904 }
905 }
906 let api_that_guard = api_that_guard.unwrap();
907 let output_ok =
908 crate::bindings::BindingLiquidSdk::lnurl_pay(&*api_that_guard, api_req)
909 .await?;
910 Ok(output_ok)
911 })()
912 .await,
913 )
914 }
915 },
916 )
917}
918fn wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(
919 port_: flutter_rust_bridge::for_generated::MessagePort,
920 that: impl CstDecode<
921 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
922 >,
923 req: impl CstDecode<crate::bindings::LnUrlWithdrawRequest>,
924) {
925 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
926 flutter_rust_bridge::for_generated::TaskInfo {
927 debug_name: "BindingLiquidSdk_lnurl_withdraw",
928 port: Some(port_),
929 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
930 },
931 move || {
932 let api_that = that.cst_decode();
933 let api_req = req.cst_decode();
934 move |context| async move {
935 transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlWithdrawError>(
936 (move || async move {
937 let mut api_that_guard = None;
938 let decode_indices_ =
939 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
940 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
941 &api_that, 0, false,
942 )],
943 );
944 for i in decode_indices_ {
945 match i {
946 0 => {
947 api_that_guard =
948 Some(api_that.lockable_decode_async_ref().await)
949 }
950 _ => unreachable!(),
951 }
952 }
953 let api_that_guard = api_that_guard.unwrap();
954 let output_ok = crate::bindings::BindingLiquidSdk::lnurl_withdraw(
955 &*api_that_guard,
956 api_req,
957 )
958 .await?;
959 Ok(output_ok)
960 })()
961 .await,
962 )
963 }
964 },
965 )
966}
967fn wire__crate__bindings__BindingLiquidSdk_parse_impl(
968 port_: flutter_rust_bridge::for_generated::MessagePort,
969 that: impl CstDecode<
970 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
971 >,
972 input: impl CstDecode<String>,
973) {
974 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
975 flutter_rust_bridge::for_generated::TaskInfo {
976 debug_name: "BindingLiquidSdk_parse",
977 port: Some(port_),
978 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
979 },
980 move || {
981 let api_that = that.cst_decode();
982 let api_input = input.cst_decode();
983 move |context| async move {
984 transform_result_dco::<_, _, crate::error::PaymentError>(
985 (move || async move {
986 let mut api_that_guard = None;
987 let decode_indices_ =
988 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
989 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
990 &api_that, 0, false,
991 )],
992 );
993 for i in decode_indices_ {
994 match i {
995 0 => {
996 api_that_guard =
997 Some(api_that.lockable_decode_async_ref().await)
998 }
999 _ => unreachable!(),
1000 }
1001 }
1002 let api_that_guard = api_that_guard.unwrap();
1003 let output_ok =
1004 crate::bindings::BindingLiquidSdk::parse(&*api_that_guard, api_input)
1005 .await?;
1006 Ok(output_ok)
1007 })()
1008 .await,
1009 )
1010 }
1011 },
1012 )
1013}
1014fn wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(
1015 port_: flutter_rust_bridge::for_generated::MessagePort,
1016 that: impl CstDecode<
1017 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1018 >,
1019 req: impl CstDecode<crate::model::PayOnchainRequest>,
1020) {
1021 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1022 flutter_rust_bridge::for_generated::TaskInfo {
1023 debug_name: "BindingLiquidSdk_pay_onchain",
1024 port: Some(port_),
1025 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1026 },
1027 move || {
1028 let api_that = that.cst_decode();
1029 let api_req = req.cst_decode();
1030 move |context| async move {
1031 transform_result_dco::<_, _, crate::error::PaymentError>(
1032 (move || async move {
1033 let mut api_that_guard = None;
1034 let decode_indices_ =
1035 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1036 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1037 &api_that, 0, false,
1038 )],
1039 );
1040 for i in decode_indices_ {
1041 match i {
1042 0 => {
1043 api_that_guard =
1044 Some(api_that.lockable_decode_async_ref().await)
1045 }
1046 _ => unreachable!(),
1047 }
1048 }
1049 let api_that_guard = api_that_guard.unwrap();
1050 let output_ok = crate::bindings::BindingLiquidSdk::pay_onchain(
1051 &*api_that_guard,
1052 api_req,
1053 )
1054 .await?;
1055 Ok(output_ok)
1056 })()
1057 .await,
1058 )
1059 }
1060 },
1061 )
1062}
1063fn wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(
1064 port_: flutter_rust_bridge::for_generated::MessagePort,
1065 that: impl CstDecode<
1066 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1067 >,
1068 req: impl CstDecode<crate::model::PrepareBuyBitcoinRequest>,
1069) {
1070 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1071 flutter_rust_bridge::for_generated::TaskInfo {
1072 debug_name: "BindingLiquidSdk_prepare_buy_bitcoin",
1073 port: Some(port_),
1074 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1075 },
1076 move || {
1077 let api_that = that.cst_decode();
1078 let api_req = req.cst_decode();
1079 move |context| async move {
1080 transform_result_dco::<_, _, crate::error::PaymentError>(
1081 (move || async move {
1082 let mut api_that_guard = None;
1083 let decode_indices_ =
1084 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1085 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1086 &api_that, 0, false,
1087 )],
1088 );
1089 for i in decode_indices_ {
1090 match i {
1091 0 => {
1092 api_that_guard =
1093 Some(api_that.lockable_decode_async_ref().await)
1094 }
1095 _ => unreachable!(),
1096 }
1097 }
1098 let api_that_guard = api_that_guard.unwrap();
1099 let output_ok = crate::bindings::BindingLiquidSdk::prepare_buy_bitcoin(
1100 &*api_that_guard,
1101 api_req,
1102 )
1103 .await?;
1104 Ok(output_ok)
1105 })()
1106 .await,
1107 )
1108 }
1109 },
1110 )
1111}
1112fn wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(
1113 port_: flutter_rust_bridge::for_generated::MessagePort,
1114 that: impl CstDecode<
1115 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1116 >,
1117 req: impl CstDecode<crate::model::PrepareLnUrlPayRequest>,
1118) {
1119 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1120 flutter_rust_bridge::for_generated::TaskInfo {
1121 debug_name: "BindingLiquidSdk_prepare_lnurl_pay",
1122 port: Some(port_),
1123 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1124 },
1125 move || {
1126 let api_that = that.cst_decode();
1127 let api_req = req.cst_decode();
1128 move |context| async move {
1129 transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlPayError>(
1130 (move || async move {
1131 let mut api_that_guard = None;
1132 let decode_indices_ =
1133 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1134 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1135 &api_that, 0, false,
1136 )],
1137 );
1138 for i in decode_indices_ {
1139 match i {
1140 0 => {
1141 api_that_guard =
1142 Some(api_that.lockable_decode_async_ref().await)
1143 }
1144 _ => unreachable!(),
1145 }
1146 }
1147 let api_that_guard = api_that_guard.unwrap();
1148 let output_ok = crate::bindings::BindingLiquidSdk::prepare_lnurl_pay(
1149 &*api_that_guard,
1150 api_req,
1151 )
1152 .await?;
1153 Ok(output_ok)
1154 })()
1155 .await,
1156 )
1157 }
1158 },
1159 )
1160}
1161fn wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(
1162 port_: flutter_rust_bridge::for_generated::MessagePort,
1163 that: impl CstDecode<
1164 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1165 >,
1166 req: impl CstDecode<crate::model::PreparePayOnchainRequest>,
1167) {
1168 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1169 flutter_rust_bridge::for_generated::TaskInfo {
1170 debug_name: "BindingLiquidSdk_prepare_pay_onchain",
1171 port: Some(port_),
1172 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1173 },
1174 move || {
1175 let api_that = that.cst_decode();
1176 let api_req = req.cst_decode();
1177 move |context| async move {
1178 transform_result_dco::<_, _, crate::error::PaymentError>(
1179 (move || async move {
1180 let mut api_that_guard = None;
1181 let decode_indices_ =
1182 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1183 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1184 &api_that, 0, false,
1185 )],
1186 );
1187 for i in decode_indices_ {
1188 match i {
1189 0 => {
1190 api_that_guard =
1191 Some(api_that.lockable_decode_async_ref().await)
1192 }
1193 _ => unreachable!(),
1194 }
1195 }
1196 let api_that_guard = api_that_guard.unwrap();
1197 let output_ok = crate::bindings::BindingLiquidSdk::prepare_pay_onchain(
1198 &*api_that_guard,
1199 api_req,
1200 )
1201 .await?;
1202 Ok(output_ok)
1203 })()
1204 .await,
1205 )
1206 }
1207 },
1208 )
1209}
1210fn wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(
1211 port_: flutter_rust_bridge::for_generated::MessagePort,
1212 that: impl CstDecode<
1213 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1214 >,
1215 req: impl CstDecode<crate::model::PrepareReceiveRequest>,
1216) {
1217 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1218 flutter_rust_bridge::for_generated::TaskInfo {
1219 debug_name: "BindingLiquidSdk_prepare_receive_payment",
1220 port: Some(port_),
1221 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1222 },
1223 move || {
1224 let api_that = that.cst_decode();
1225 let api_req = req.cst_decode();
1226 move |context| async move {
1227 transform_result_dco::<_, _, crate::error::PaymentError>(
1228 (move || async move {
1229 let mut api_that_guard = None;
1230 let decode_indices_ =
1231 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1232 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1233 &api_that, 0, false,
1234 )],
1235 );
1236 for i in decode_indices_ {
1237 match i {
1238 0 => {
1239 api_that_guard =
1240 Some(api_that.lockable_decode_async_ref().await)
1241 }
1242 _ => unreachable!(),
1243 }
1244 }
1245 let api_that_guard = api_that_guard.unwrap();
1246 let output_ok = crate::bindings::BindingLiquidSdk::prepare_receive_payment(
1247 &*api_that_guard,
1248 api_req,
1249 )
1250 .await?;
1251 Ok(output_ok)
1252 })()
1253 .await,
1254 )
1255 }
1256 },
1257 )
1258}
1259fn wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(
1260 port_: flutter_rust_bridge::for_generated::MessagePort,
1261 that: impl CstDecode<
1262 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1263 >,
1264 req: impl CstDecode<crate::model::PrepareRefundRequest>,
1265) {
1266 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1267 flutter_rust_bridge::for_generated::TaskInfo {
1268 debug_name: "BindingLiquidSdk_prepare_refund",
1269 port: Some(port_),
1270 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1271 },
1272 move || {
1273 let api_that = that.cst_decode();
1274 let api_req = req.cst_decode();
1275 move |context| async move {
1276 transform_result_dco::<_, _, crate::error::SdkError>(
1277 (move || async move {
1278 let mut api_that_guard = None;
1279 let decode_indices_ =
1280 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1281 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1282 &api_that, 0, false,
1283 )],
1284 );
1285 for i in decode_indices_ {
1286 match i {
1287 0 => {
1288 api_that_guard =
1289 Some(api_that.lockable_decode_async_ref().await)
1290 }
1291 _ => unreachable!(),
1292 }
1293 }
1294 let api_that_guard = api_that_guard.unwrap();
1295 let output_ok = crate::bindings::BindingLiquidSdk::prepare_refund(
1296 &*api_that_guard,
1297 api_req,
1298 )
1299 .await?;
1300 Ok(output_ok)
1301 })()
1302 .await,
1303 )
1304 }
1305 },
1306 )
1307}
1308fn wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(
1309 port_: flutter_rust_bridge::for_generated::MessagePort,
1310 that: impl CstDecode<
1311 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1312 >,
1313 req: impl CstDecode<crate::model::PrepareSendRequest>,
1314) {
1315 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1316 flutter_rust_bridge::for_generated::TaskInfo {
1317 debug_name: "BindingLiquidSdk_prepare_send_payment",
1318 port: Some(port_),
1319 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1320 },
1321 move || {
1322 let api_that = that.cst_decode();
1323 let api_req = req.cst_decode();
1324 move |context| async move {
1325 transform_result_dco::<_, _, crate::error::PaymentError>(
1326 (move || async move {
1327 let mut api_that_guard = None;
1328 let decode_indices_ =
1329 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1330 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1331 &api_that, 0, false,
1332 )],
1333 );
1334 for i in decode_indices_ {
1335 match i {
1336 0 => {
1337 api_that_guard =
1338 Some(api_that.lockable_decode_async_ref().await)
1339 }
1340 _ => unreachable!(),
1341 }
1342 }
1343 let api_that_guard = api_that_guard.unwrap();
1344 let output_ok = crate::bindings::BindingLiquidSdk::prepare_send_payment(
1345 &*api_that_guard,
1346 api_req,
1347 )
1348 .await?;
1349 Ok(output_ok)
1350 })()
1351 .await,
1352 )
1353 }
1354 },
1355 )
1356}
1357fn wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(
1358 port_: flutter_rust_bridge::for_generated::MessagePort,
1359 that: impl CstDecode<
1360 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1361 >,
1362 req: impl CstDecode<crate::model::ReceivePaymentRequest>,
1363) {
1364 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1365 flutter_rust_bridge::for_generated::TaskInfo {
1366 debug_name: "BindingLiquidSdk_receive_payment",
1367 port: Some(port_),
1368 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1369 },
1370 move || {
1371 let api_that = that.cst_decode();
1372 let api_req = req.cst_decode();
1373 move |context| async move {
1374 transform_result_dco::<_, _, crate::error::PaymentError>(
1375 (move || async move {
1376 let mut api_that_guard = None;
1377 let decode_indices_ =
1378 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1379 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1380 &api_that, 0, false,
1381 )],
1382 );
1383 for i in decode_indices_ {
1384 match i {
1385 0 => {
1386 api_that_guard =
1387 Some(api_that.lockable_decode_async_ref().await)
1388 }
1389 _ => unreachable!(),
1390 }
1391 }
1392 let api_that_guard = api_that_guard.unwrap();
1393 let output_ok = crate::bindings::BindingLiquidSdk::receive_payment(
1394 &*api_that_guard,
1395 api_req,
1396 )
1397 .await?;
1398 Ok(output_ok)
1399 })()
1400 .await,
1401 )
1402 }
1403 },
1404 )
1405}
1406fn wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(
1407 port_: flutter_rust_bridge::for_generated::MessagePort,
1408 that: impl CstDecode<
1409 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1410 >,
1411) {
1412 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1413 flutter_rust_bridge::for_generated::TaskInfo {
1414 debug_name: "BindingLiquidSdk_recommended_fees",
1415 port: Some(port_),
1416 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1417 },
1418 move || {
1419 let api_that = that.cst_decode();
1420 move |context| async move {
1421 transform_result_dco::<_, _, crate::error::SdkError>(
1422 (move || async move {
1423 let mut api_that_guard = None;
1424 let decode_indices_ =
1425 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1426 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1427 &api_that, 0, false,
1428 )],
1429 );
1430 for i in decode_indices_ {
1431 match i {
1432 0 => {
1433 api_that_guard =
1434 Some(api_that.lockable_decode_async_ref().await)
1435 }
1436 _ => unreachable!(),
1437 }
1438 }
1439 let api_that_guard = api_that_guard.unwrap();
1440 let output_ok =
1441 crate::bindings::BindingLiquidSdk::recommended_fees(&*api_that_guard)
1442 .await?;
1443 Ok(output_ok)
1444 })()
1445 .await,
1446 )
1447 }
1448 },
1449 )
1450}
1451fn wire__crate__bindings__BindingLiquidSdk_refund_impl(
1452 port_: flutter_rust_bridge::for_generated::MessagePort,
1453 that: impl CstDecode<
1454 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1455 >,
1456 req: impl CstDecode<crate::model::RefundRequest>,
1457) {
1458 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1459 flutter_rust_bridge::for_generated::TaskInfo {
1460 debug_name: "BindingLiquidSdk_refund",
1461 port: Some(port_),
1462 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1463 },
1464 move || {
1465 let api_that = that.cst_decode();
1466 let api_req = req.cst_decode();
1467 move |context| async move {
1468 transform_result_dco::<_, _, crate::error::PaymentError>(
1469 (move || async move {
1470 let mut api_that_guard = None;
1471 let decode_indices_ =
1472 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1473 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1474 &api_that, 0, false,
1475 )],
1476 );
1477 for i in decode_indices_ {
1478 match i {
1479 0 => {
1480 api_that_guard =
1481 Some(api_that.lockable_decode_async_ref().await)
1482 }
1483 _ => unreachable!(),
1484 }
1485 }
1486 let api_that_guard = api_that_guard.unwrap();
1487 let output_ok =
1488 crate::bindings::BindingLiquidSdk::refund(&*api_that_guard, api_req)
1489 .await?;
1490 Ok(output_ok)
1491 })()
1492 .await,
1493 )
1494 }
1495 },
1496 )
1497}
1498fn wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(
1499 port_: flutter_rust_bridge::for_generated::MessagePort,
1500 that: impl CstDecode<
1501 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1502 >,
1503 webhook_url: impl CstDecode<String>,
1504) {
1505 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1506 flutter_rust_bridge::for_generated::TaskInfo {
1507 debug_name: "BindingLiquidSdk_register_webhook",
1508 port: Some(port_),
1509 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1510 },
1511 move || {
1512 let api_that = that.cst_decode();
1513 let api_webhook_url = webhook_url.cst_decode();
1514 move |context| async move {
1515 transform_result_dco::<_, _, crate::error::SdkError>(
1516 (move || async move {
1517 let mut api_that_guard = None;
1518 let decode_indices_ =
1519 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1520 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1521 &api_that, 0, false,
1522 )],
1523 );
1524 for i in decode_indices_ {
1525 match i {
1526 0 => {
1527 api_that_guard =
1528 Some(api_that.lockable_decode_async_ref().await)
1529 }
1530 _ => unreachable!(),
1531 }
1532 }
1533 let api_that_guard = api_that_guard.unwrap();
1534 let output_ok = crate::bindings::BindingLiquidSdk::register_webhook(
1535 &*api_that_guard,
1536 api_webhook_url,
1537 )
1538 .await?;
1539 Ok(output_ok)
1540 })()
1541 .await,
1542 )
1543 }
1544 },
1545 )
1546}
1547fn wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(
1548 port_: flutter_rust_bridge::for_generated::MessagePort,
1549 that: impl CstDecode<
1550 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1551 >,
1552) {
1553 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1554 flutter_rust_bridge::for_generated::TaskInfo {
1555 debug_name: "BindingLiquidSdk_rescan_onchain_swaps",
1556 port: Some(port_),
1557 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1558 },
1559 move || {
1560 let api_that = that.cst_decode();
1561 move |context| async move {
1562 transform_result_dco::<_, _, crate::error::SdkError>(
1563 (move || async move {
1564 let mut api_that_guard = None;
1565 let decode_indices_ =
1566 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1567 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1568 &api_that, 0, false,
1569 )],
1570 );
1571 for i in decode_indices_ {
1572 match i {
1573 0 => {
1574 api_that_guard =
1575 Some(api_that.lockable_decode_async_ref().await)
1576 }
1577 _ => unreachable!(),
1578 }
1579 }
1580 let api_that_guard = api_that_guard.unwrap();
1581 let output_ok = crate::bindings::BindingLiquidSdk::rescan_onchain_swaps(
1582 &*api_that_guard,
1583 )
1584 .await?;
1585 Ok(output_ok)
1586 })()
1587 .await,
1588 )
1589 }
1590 },
1591 )
1592}
1593fn wire__crate__bindings__BindingLiquidSdk_restore_impl(
1594 that: impl CstDecode<
1595 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1596 >,
1597 req: impl CstDecode<crate::model::RestoreRequest>,
1598) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1599 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1600 flutter_rust_bridge::for_generated::TaskInfo {
1601 debug_name: "BindingLiquidSdk_restore",
1602 port: None,
1603 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1604 },
1605 move || {
1606 let api_that = that.cst_decode();
1607 let api_req = req.cst_decode();
1608 transform_result_dco::<_, _, crate::error::SdkError>((move || {
1609 let mut api_that_guard = None;
1610 let decode_indices_ =
1611 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
1612 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1613 &api_that, 0, false,
1614 ),
1615 ]);
1616 for i in decode_indices_ {
1617 match i {
1618 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
1619 _ => unreachable!(),
1620 }
1621 }
1622 let api_that_guard = api_that_guard.unwrap();
1623 let output_ok =
1624 crate::bindings::BindingLiquidSdk::restore(&*api_that_guard, api_req)?;
1625 Ok(output_ok)
1626 })())
1627 },
1628 )
1629}
1630fn wire__crate__bindings__BindingLiquidSdk_send_payment_impl(
1631 port_: flutter_rust_bridge::for_generated::MessagePort,
1632 that: impl CstDecode<
1633 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1634 >,
1635 req: impl CstDecode<crate::model::SendPaymentRequest>,
1636) {
1637 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1638 flutter_rust_bridge::for_generated::TaskInfo {
1639 debug_name: "BindingLiquidSdk_send_payment",
1640 port: Some(port_),
1641 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1642 },
1643 move || {
1644 let api_that = that.cst_decode();
1645 let api_req = req.cst_decode();
1646 move |context| async move {
1647 transform_result_dco::<_, _, crate::error::PaymentError>(
1648 (move || async move {
1649 let mut api_that_guard = None;
1650 let decode_indices_ =
1651 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1652 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1653 &api_that, 0, false,
1654 )],
1655 );
1656 for i in decode_indices_ {
1657 match i {
1658 0 => {
1659 api_that_guard =
1660 Some(api_that.lockable_decode_async_ref().await)
1661 }
1662 _ => unreachable!(),
1663 }
1664 }
1665 let api_that_guard = api_that_guard.unwrap();
1666 let output_ok = crate::bindings::BindingLiquidSdk::send_payment(
1667 &*api_that_guard,
1668 api_req,
1669 )
1670 .await?;
1671 Ok(output_ok)
1672 })()
1673 .await,
1674 )
1675 }
1676 },
1677 )
1678}
1679fn wire__crate__bindings__BindingLiquidSdk_sign_message_impl(
1680 that: impl CstDecode<
1681 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1682 >,
1683 req: impl CstDecode<crate::model::SignMessageRequest>,
1684) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1685 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1686 flutter_rust_bridge::for_generated::TaskInfo {
1687 debug_name: "BindingLiquidSdk_sign_message",
1688 port: None,
1689 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1690 },
1691 move || {
1692 let api_that = that.cst_decode();
1693 let api_req = req.cst_decode();
1694 transform_result_dco::<_, _, crate::error::SdkError>((move || {
1695 let mut api_that_guard = None;
1696 let decode_indices_ =
1697 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
1698 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1699 &api_that, 0, false,
1700 ),
1701 ]);
1702 for i in decode_indices_ {
1703 match i {
1704 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
1705 _ => unreachable!(),
1706 }
1707 }
1708 let api_that_guard = api_that_guard.unwrap();
1709 let output_ok =
1710 crate::bindings::BindingLiquidSdk::sign_message(&*api_that_guard, api_req)?;
1711 Ok(output_ok)
1712 })())
1713 },
1714 )
1715}
1716fn wire__crate__bindings__BindingLiquidSdk_sync_impl(
1717 port_: flutter_rust_bridge::for_generated::MessagePort,
1718 that: impl CstDecode<
1719 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1720 >,
1721) {
1722 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1723 flutter_rust_bridge::for_generated::TaskInfo {
1724 debug_name: "BindingLiquidSdk_sync(dart_style=sync)",
1725 port: Some(port_),
1726 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1727 },
1728 move || {
1729 let api_that = that.cst_decode();
1730 move |context| async move {
1731 transform_result_dco::<_, _, crate::error::SdkError>(
1732 (move || async move {
1733 let mut api_that_guard = None;
1734 let decode_indices_ =
1735 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1736 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1737 &api_that, 0, false,
1738 )],
1739 );
1740 for i in decode_indices_ {
1741 match i {
1742 0 => {
1743 api_that_guard =
1744 Some(api_that.lockable_decode_async_ref().await)
1745 }
1746 _ => unreachable!(),
1747 }
1748 }
1749 let api_that_guard = api_that_guard.unwrap();
1750 let output_ok =
1751 crate::bindings::BindingLiquidSdk::sync(&*api_that_guard).await?;
1752 Ok(output_ok)
1753 })()
1754 .await,
1755 )
1756 }
1757 },
1758 )
1759}
1760fn wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(
1761 port_: flutter_rust_bridge::for_generated::MessagePort,
1762 that: impl CstDecode<
1763 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1764 >,
1765) {
1766 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1767 flutter_rust_bridge::for_generated::TaskInfo {
1768 debug_name: "BindingLiquidSdk_unregister_webhook",
1769 port: Some(port_),
1770 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1771 },
1772 move || {
1773 let api_that = that.cst_decode();
1774 move |context| async move {
1775 transform_result_dco::<_, _, crate::error::SdkError>(
1776 (move || async move {
1777 let mut api_that_guard = None;
1778 let decode_indices_ =
1779 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1780 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1781 &api_that, 0, false,
1782 )],
1783 );
1784 for i in decode_indices_ {
1785 match i {
1786 0 => {
1787 api_that_guard =
1788 Some(api_that.lockable_decode_async_ref().await)
1789 }
1790 _ => unreachable!(),
1791 }
1792 }
1793 let api_that_guard = api_that_guard.unwrap();
1794 let output_ok =
1795 crate::bindings::BindingLiquidSdk::unregister_webhook(&*api_that_guard)
1796 .await?;
1797 Ok(output_ok)
1798 })()
1799 .await,
1800 )
1801 }
1802 },
1803 )
1804}
1805fn wire__crate__bindings__binding_event_listener_on_event_impl(
1806 port_: flutter_rust_bridge::for_generated::MessagePort,
1807 that: impl CstDecode<crate::bindings::BindingEventListener>,
1808 e: impl CstDecode<crate::model::SdkEvent>,
1809) {
1810 FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
1811 flutter_rust_bridge::for_generated::TaskInfo {
1812 debug_name: "binding_event_listener_on_event",
1813 port: Some(port_),
1814 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1815 },
1816 move || {
1817 let api_that = that.cst_decode();
1818 let api_e = e.cst_decode();
1819 move |context| {
1820 transform_result_dco::<_, _, ()>((move || {
1821 let output_ok = Result::<_, ()>::Ok({
1822 crate::bindings::BindingEventListener::on_event(&api_that, api_e);
1823 })?;
1824 Ok(output_ok)
1825 })())
1826 }
1827 },
1828 )
1829}
1830fn wire__crate__bindings__breez_log_stream_impl(
1831 port_: flutter_rust_bridge::for_generated::MessagePort,
1832 s: impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>,
1833) {
1834 FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
1835 flutter_rust_bridge::for_generated::TaskInfo {
1836 debug_name: "breez_log_stream",
1837 port: Some(port_),
1838 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1839 },
1840 move || {
1841 let api_s = s.cst_decode();
1842 move |context| {
1843 transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
1844 (move || {
1845 let output_ok = crate::bindings::breez_log_stream(api_s)?;
1846 Ok(output_ok)
1847 })(),
1848 )
1849 }
1850 },
1851 )
1852}
1853fn wire__crate__bindings__connect_impl(
1854 port_: flutter_rust_bridge::for_generated::MessagePort,
1855 req: impl CstDecode<crate::model::ConnectRequest>,
1856) {
1857 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1858 flutter_rust_bridge::for_generated::TaskInfo {
1859 debug_name: "connect",
1860 port: Some(port_),
1861 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1862 },
1863 move || {
1864 let api_req = req.cst_decode();
1865 move |context| async move {
1866 transform_result_dco::<_, _, crate::error::SdkError>(
1867 (move || async move {
1868 let output_ok = crate::bindings::connect(api_req).await?;
1869 Ok(output_ok)
1870 })()
1871 .await,
1872 )
1873 }
1874 },
1875 )
1876}
1877fn wire__crate__bindings__default_config_impl(
1878 network: impl CstDecode<crate::model::LiquidNetwork>,
1879 breez_api_key: impl CstDecode<Option<String>>,
1880) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1881 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1882 flutter_rust_bridge::for_generated::TaskInfo {
1883 debug_name: "default_config",
1884 port: None,
1885 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1886 },
1887 move || {
1888 let api_network = network.cst_decode();
1889 let api_breez_api_key = breez_api_key.cst_decode();
1890 transform_result_dco::<_, _, crate::error::SdkError>((move || {
1891 let output_ok = crate::bindings::default_config(api_network, api_breez_api_key)?;
1892 Ok(output_ok)
1893 })())
1894 },
1895 )
1896}
1897fn wire__crate__bindings__parse_invoice_impl(
1898 input: impl CstDecode<String>,
1899) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1900 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1901 flutter_rust_bridge::for_generated::TaskInfo {
1902 debug_name: "parse_invoice",
1903 port: None,
1904 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1905 },
1906 move || {
1907 let api_input = input.cst_decode();
1908 transform_result_dco::<_, _, crate::error::PaymentError>((move || {
1909 let output_ok = crate::bindings::parse_invoice(api_input)?;
1910 Ok(output_ok)
1911 })())
1912 },
1913 )
1914}
1915
1916#[allow(clippy::unnecessary_literal_unwrap)]
1919const _: fn() = || {
1920 {
1921 let AesSuccessActionData = None::<crate::bindings::AesSuccessActionData>.unwrap();
1922 let _: String = AesSuccessActionData.description;
1923 let _: String = AesSuccessActionData.ciphertext;
1924 let _: String = AesSuccessActionData.iv;
1925 }
1926 {
1927 let AesSuccessActionDataDecrypted =
1928 None::<crate::bindings::AesSuccessActionDataDecrypted>.unwrap();
1929 let _: String = AesSuccessActionDataDecrypted.description;
1930 let _: String = AesSuccessActionDataDecrypted.plaintext;
1931 }
1932 match None::<crate::bindings::AesSuccessActionDataResult>.unwrap() {
1933 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
1934 let _: crate::bindings::AesSuccessActionDataDecrypted = data;
1935 }
1936 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
1937 let _: String = reason;
1938 }
1939 }
1940 match None::<crate::bindings::Amount>.unwrap() {
1941 crate::bindings::Amount::Bitcoin { amount_msat } => {
1942 let _: u64 = amount_msat;
1943 }
1944 crate::bindings::Amount::Currency {
1945 iso4217_code,
1946 fractional_amount,
1947 } => {
1948 let _: String = iso4217_code;
1949 let _: u64 = fractional_amount;
1950 }
1951 }
1952 {
1953 let BitcoinAddressData = None::<crate::bindings::BitcoinAddressData>.unwrap();
1954 let _: String = BitcoinAddressData.address;
1955 let _: crate::bindings::Network = BitcoinAddressData.network;
1956 let _: Option<u64> = BitcoinAddressData.amount_sat;
1957 let _: Option<String> = BitcoinAddressData.label;
1958 let _: Option<String> = BitcoinAddressData.message;
1959 }
1960 {
1961 let CurrencyInfo = None::<crate::bindings::CurrencyInfo>.unwrap();
1962 let _: String = CurrencyInfo.name;
1963 let _: u32 = CurrencyInfo.fraction_size;
1964 let _: Option<u32> = CurrencyInfo.spacing;
1965 let _: Option<crate::bindings::Symbol> = CurrencyInfo.symbol;
1966 let _: Option<crate::bindings::Symbol> = CurrencyInfo.uniq_symbol;
1967 let _: Vec<crate::bindings::LocalizedName> = CurrencyInfo.localized_name;
1968 let _: Vec<crate::bindings::LocaleOverrides> = CurrencyInfo.locale_overrides;
1969 }
1970 {
1971 let ExternalInputParser = None::<crate::bindings::ExternalInputParser>.unwrap();
1972 let _: String = ExternalInputParser.provider_id;
1973 let _: String = ExternalInputParser.input_regex;
1974 let _: String = ExternalInputParser.parser_url;
1975 }
1976 {
1977 let FiatCurrency = None::<crate::bindings::FiatCurrency>.unwrap();
1978 let _: String = FiatCurrency.id;
1979 let _: crate::bindings::CurrencyInfo = FiatCurrency.info;
1980 }
1981 match None::<crate::bindings::InputType>.unwrap() {
1982 crate::bindings::InputType::BitcoinAddress { address } => {
1983 let _: crate::bindings::BitcoinAddressData = address;
1984 }
1985 crate::bindings::InputType::LiquidAddress { address } => {
1986 let _: crate::bindings::LiquidAddressData = address;
1987 }
1988 crate::bindings::InputType::Bolt11 { invoice } => {
1989 let _: crate::bindings::LNInvoice = invoice;
1990 }
1991 crate::bindings::InputType::Bolt12Offer {
1992 offer,
1993 bip353_address,
1994 } => {
1995 let _: crate::bindings::LNOffer = offer;
1996 let _: Option<String> = bip353_address;
1997 }
1998 crate::bindings::InputType::NodeId { node_id } => {
1999 let _: String = node_id;
2000 }
2001 crate::bindings::InputType::Url { url } => {
2002 let _: String = url;
2003 }
2004 crate::bindings::InputType::LnUrlPay {
2005 data,
2006 bip353_address,
2007 } => {
2008 let _: crate::bindings::LnUrlPayRequestData = data;
2009 let _: Option<String> = bip353_address;
2010 }
2011 crate::bindings::InputType::LnUrlWithdraw { data } => {
2012 let _: crate::bindings::LnUrlWithdrawRequestData = data;
2013 }
2014 crate::bindings::InputType::LnUrlAuth { data } => {
2015 let _: crate::bindings::LnUrlAuthRequestData = data;
2016 }
2017 crate::bindings::InputType::LnUrlError { data } => {
2018 let _: crate::bindings::LnUrlErrorData = data;
2019 }
2020 }
2021 {
2022 let LiquidAddressData = None::<crate::bindings::LiquidAddressData>.unwrap();
2023 let _: String = LiquidAddressData.address;
2024 let _: crate::bindings::Network = LiquidAddressData.network;
2025 let _: Option<String> = LiquidAddressData.asset_id;
2026 let _: Option<f64> = LiquidAddressData.amount;
2027 let _: Option<u64> = LiquidAddressData.amount_sat;
2028 let _: Option<String> = LiquidAddressData.label;
2029 let _: Option<String> = LiquidAddressData.message;
2030 }
2031 {
2032 let LNInvoice = None::<crate::bindings::LNInvoice>.unwrap();
2033 let _: String = LNInvoice.bolt11;
2034 let _: crate::bindings::Network = LNInvoice.network;
2035 let _: String = LNInvoice.payee_pubkey;
2036 let _: String = LNInvoice.payment_hash;
2037 let _: Option<String> = LNInvoice.description;
2038 let _: Option<String> = LNInvoice.description_hash;
2039 let _: Option<u64> = LNInvoice.amount_msat;
2040 let _: u64 = LNInvoice.timestamp;
2041 let _: u64 = LNInvoice.expiry;
2042 let _: Vec<crate::bindings::RouteHint> = LNInvoice.routing_hints;
2043 let _: Vec<u8> = LNInvoice.payment_secret;
2044 let _: u64 = LNInvoice.min_final_cltv_expiry_delta;
2045 }
2046 {
2047 let LNOffer = None::<crate::bindings::LNOffer>.unwrap();
2048 let _: String = LNOffer.offer;
2049 let _: Vec<String> = LNOffer.chains;
2050 let _: Option<crate::bindings::Amount> = LNOffer.min_amount;
2051 let _: Option<String> = LNOffer.description;
2052 let _: Option<u64> = LNOffer.absolute_expiry;
2053 let _: Option<String> = LNOffer.issuer;
2054 let _: Option<String> = LNOffer.signing_pubkey;
2055 let _: Vec<crate::bindings::LnOfferBlindedPath> = LNOffer.paths;
2056 }
2057 {
2058 let LnOfferBlindedPath = None::<crate::bindings::LnOfferBlindedPath>.unwrap();
2059 let _: Vec<String> = LnOfferBlindedPath.blinded_hops;
2060 }
2061 {
2062 let LnUrlAuthRequestData = None::<crate::bindings::LnUrlAuthRequestData>.unwrap();
2063 let _: String = LnUrlAuthRequestData.k1;
2064 let _: Option<String> = LnUrlAuthRequestData.action;
2065 let _: String = LnUrlAuthRequestData.domain;
2066 let _: String = LnUrlAuthRequestData.url;
2067 }
2068 {
2069 let LnUrlErrorData = None::<crate::bindings::LnUrlErrorData>.unwrap();
2070 let _: String = LnUrlErrorData.reason;
2071 }
2072 {
2073 let LnUrlPayErrorData = None::<crate::bindings::LnUrlPayErrorData>.unwrap();
2074 let _: String = LnUrlPayErrorData.payment_hash;
2075 let _: String = LnUrlPayErrorData.reason;
2076 }
2077 {
2078 let LnUrlPayRequestData = None::<crate::bindings::LnUrlPayRequestData>.unwrap();
2079 let _: String = LnUrlPayRequestData.callback;
2080 let _: u64 = LnUrlPayRequestData.min_sendable;
2081 let _: u64 = LnUrlPayRequestData.max_sendable;
2082 let _: String = LnUrlPayRequestData.metadata_str;
2083 let _: u16 = LnUrlPayRequestData.comment_allowed;
2084 let _: String = LnUrlPayRequestData.domain;
2085 let _: bool = LnUrlPayRequestData.allows_nostr;
2086 let _: Option<String> = LnUrlPayRequestData.nostr_pubkey;
2087 let _: Option<String> = LnUrlPayRequestData.ln_address;
2088 }
2089 {
2090 let LnUrlWithdrawRequest = None::<crate::bindings::LnUrlWithdrawRequest>.unwrap();
2091 let _: crate::bindings::LnUrlWithdrawRequestData = LnUrlWithdrawRequest.data;
2092 let _: u64 = LnUrlWithdrawRequest.amount_msat;
2093 let _: Option<String> = LnUrlWithdrawRequest.description;
2094 }
2095 {
2096 let LnUrlWithdrawRequestData = None::<crate::bindings::LnUrlWithdrawRequestData>.unwrap();
2097 let _: String = LnUrlWithdrawRequestData.callback;
2098 let _: String = LnUrlWithdrawRequestData.k1;
2099 let _: String = LnUrlWithdrawRequestData.default_description;
2100 let _: u64 = LnUrlWithdrawRequestData.min_withdrawable;
2101 let _: u64 = LnUrlWithdrawRequestData.max_withdrawable;
2102 }
2103 {
2104 let LocaleOverrides = None::<crate::bindings::LocaleOverrides>.unwrap();
2105 let _: String = LocaleOverrides.locale;
2106 let _: Option<u32> = LocaleOverrides.spacing;
2107 let _: crate::bindings::Symbol = LocaleOverrides.symbol;
2108 }
2109 {
2110 let LocalizedName = None::<crate::bindings::LocalizedName>.unwrap();
2111 let _: String = LocalizedName.locale;
2112 let _: String = LocalizedName.name;
2113 }
2114 {
2115 let MessageSuccessActionData = None::<crate::bindings::MessageSuccessActionData>.unwrap();
2116 let _: String = MessageSuccessActionData.message;
2117 }
2118 {
2119 let Rate = None::<crate::bindings::Rate>.unwrap();
2120 let _: String = Rate.coin;
2121 let _: f64 = Rate.value;
2122 }
2123 {
2124 let RouteHint = None::<crate::bindings::RouteHint>.unwrap();
2125 let _: Vec<crate::bindings::RouteHintHop> = RouteHint.hops;
2126 }
2127 {
2128 let RouteHintHop = None::<crate::bindings::RouteHintHop>.unwrap();
2129 let _: String = RouteHintHop.src_node_id;
2130 let _: String = RouteHintHop.short_channel_id;
2131 let _: u32 = RouteHintHop.fees_base_msat;
2132 let _: u32 = RouteHintHop.fees_proportional_millionths;
2133 let _: u64 = RouteHintHop.cltv_expiry_delta;
2134 let _: Option<u64> = RouteHintHop.htlc_minimum_msat;
2135 let _: Option<u64> = RouteHintHop.htlc_maximum_msat;
2136 }
2137 match None::<crate::bindings::SuccessAction>.unwrap() {
2138 crate::bindings::SuccessAction::Aes { data } => {
2139 let _: crate::bindings::AesSuccessActionData = data;
2140 }
2141 crate::bindings::SuccessAction::Message { data } => {
2142 let _: crate::bindings::MessageSuccessActionData = data;
2143 }
2144 crate::bindings::SuccessAction::Url { data } => {
2145 let _: crate::bindings::UrlSuccessActionData = data;
2146 }
2147 }
2148 match None::<crate::bindings::SuccessActionProcessed>.unwrap() {
2149 crate::bindings::SuccessActionProcessed::Aes { result } => {
2150 let _: crate::bindings::AesSuccessActionDataResult = result;
2151 }
2152 crate::bindings::SuccessActionProcessed::Message { data } => {
2153 let _: crate::bindings::MessageSuccessActionData = data;
2154 }
2155 crate::bindings::SuccessActionProcessed::Url { data } => {
2156 let _: crate::bindings::UrlSuccessActionData = data;
2157 }
2158 }
2159 {
2160 let Symbol = None::<crate::bindings::Symbol>.unwrap();
2161 let _: Option<String> = Symbol.grapheme;
2162 let _: Option<String> = Symbol.template;
2163 let _: Option<bool> = Symbol.rtl;
2164 let _: Option<u32> = Symbol.position;
2165 }
2166 {
2167 let UrlSuccessActionData = None::<crate::bindings::UrlSuccessActionData>.unwrap();
2168 let _: String = UrlSuccessActionData.description;
2169 let _: String = UrlSuccessActionData.url;
2170 let _: bool = UrlSuccessActionData.matches_callback_domain;
2171 }
2172};
2173
2174impl CstDecode<bool> for bool {
2177 fn cst_decode(self) -> bool {
2179 self
2180 }
2181}
2182impl CstDecode<crate::model::BuyBitcoinProvider> for i32 {
2183 fn cst_decode(self) -> crate::model::BuyBitcoinProvider {
2185 match self {
2186 0 => crate::model::BuyBitcoinProvider::Moonpay,
2187 _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", self),
2188 }
2189 }
2190}
2191impl CstDecode<f64> for f64 {
2192 fn cst_decode(self) -> f64 {
2194 self
2195 }
2196}
2197impl CstDecode<i32> for i32 {
2198 fn cst_decode(self) -> i32 {
2200 self
2201 }
2202}
2203impl CstDecode<i64> for i64 {
2204 fn cst_decode(self) -> i64 {
2206 self
2207 }
2208}
2209impl CstDecode<crate::model::LiquidNetwork> for i32 {
2210 fn cst_decode(self) -> crate::model::LiquidNetwork {
2212 match self {
2213 0 => crate::model::LiquidNetwork::Mainnet,
2214 1 => crate::model::LiquidNetwork::Testnet,
2215 2 => crate::model::LiquidNetwork::Regtest,
2216 _ => unreachable!("Invalid variant for LiquidNetwork: {}", self),
2217 }
2218 }
2219}
2220impl CstDecode<crate::bindings::Network> for i32 {
2221 fn cst_decode(self) -> crate::bindings::Network {
2223 match self {
2224 0 => crate::bindings::Network::Bitcoin,
2225 1 => crate::bindings::Network::Testnet,
2226 2 => crate::bindings::Network::Signet,
2227 3 => crate::bindings::Network::Regtest,
2228 _ => unreachable!("Invalid variant for Network: {}", self),
2229 }
2230 }
2231}
2232impl CstDecode<crate::model::PaymentMethod> for i32 {
2233 fn cst_decode(self) -> crate::model::PaymentMethod {
2235 match self {
2236 0 => crate::model::PaymentMethod::Lightning,
2237 1 => crate::model::PaymentMethod::Bolt11Invoice,
2238 2 => crate::model::PaymentMethod::Bolt12Offer,
2239 3 => crate::model::PaymentMethod::BitcoinAddress,
2240 4 => crate::model::PaymentMethod::LiquidAddress,
2241 _ => unreachable!("Invalid variant for PaymentMethod: {}", self),
2242 }
2243 }
2244}
2245impl CstDecode<crate::model::PaymentState> for i32 {
2246 fn cst_decode(self) -> crate::model::PaymentState {
2248 match self {
2249 0 => crate::model::PaymentState::Created,
2250 1 => crate::model::PaymentState::Pending,
2251 2 => crate::model::PaymentState::Complete,
2252 3 => crate::model::PaymentState::Failed,
2253 4 => crate::model::PaymentState::TimedOut,
2254 5 => crate::model::PaymentState::Refundable,
2255 6 => crate::model::PaymentState::RefundPending,
2256 7 => crate::model::PaymentState::WaitingFeeAcceptance,
2257 _ => unreachable!("Invalid variant for PaymentState: {}", self),
2258 }
2259 }
2260}
2261impl CstDecode<crate::model::PaymentType> for i32 {
2262 fn cst_decode(self) -> crate::model::PaymentType {
2264 match self {
2265 0 => crate::model::PaymentType::Receive,
2266 1 => crate::model::PaymentType::Send,
2267 _ => unreachable!("Invalid variant for PaymentType: {}", self),
2268 }
2269 }
2270}
2271impl CstDecode<u16> for u16 {
2272 fn cst_decode(self) -> u16 {
2274 self
2275 }
2276}
2277impl CstDecode<u32> for u32 {
2278 fn cst_decode(self) -> u32 {
2280 self
2281 }
2282}
2283impl CstDecode<u64> for u64 {
2284 fn cst_decode(self) -> u64 {
2286 self
2287 }
2288}
2289impl CstDecode<u8> for u8 {
2290 fn cst_decode(self) -> u8 {
2292 self
2293 }
2294}
2295impl CstDecode<usize> for usize {
2296 fn cst_decode(self) -> usize {
2298 self
2299 }
2300}
2301impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
2302 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2304 let mut inner = <String>::sse_decode(deserializer);
2305 return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
2306 }
2307}
2308
2309impl SseDecode for BindingLiquidSdk {
2310 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2312 let mut inner = <RustOpaqueNom<
2313 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
2314 >>::sse_decode(deserializer);
2315 return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
2316 }
2317}
2318
2319impl SseDecode
2320 for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
2321{
2322 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2324 let mut inner = <usize>::sse_decode(deserializer);
2325 return unsafe { decode_rust_opaque_nom(inner) };
2326 }
2327}
2328
2329impl SseDecode
2330 for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
2331{
2332 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2334 let mut inner = <String>::sse_decode(deserializer);
2335 return StreamSink::deserialize(inner);
2336 }
2337}
2338
2339impl SseDecode
2340 for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
2341{
2342 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2344 let mut inner = <String>::sse_decode(deserializer);
2345 return StreamSink::deserialize(inner);
2346 }
2347}
2348
2349impl SseDecode for String {
2350 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2352 let mut inner = <Vec<u8>>::sse_decode(deserializer);
2353 return String::from_utf8(inner).unwrap();
2354 }
2355}
2356
2357impl SseDecode for crate::model::AcceptPaymentProposedFeesRequest {
2358 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2360 let mut var_response =
2361 <crate::model::FetchPaymentProposedFeesResponse>::sse_decode(deserializer);
2362 return crate::model::AcceptPaymentProposedFeesRequest {
2363 response: var_response,
2364 };
2365 }
2366}
2367
2368impl SseDecode for crate::bindings::AesSuccessActionData {
2369 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2371 let mut var_description = <String>::sse_decode(deserializer);
2372 let mut var_ciphertext = <String>::sse_decode(deserializer);
2373 let mut var_iv = <String>::sse_decode(deserializer);
2374 return crate::bindings::AesSuccessActionData {
2375 description: var_description,
2376 ciphertext: var_ciphertext,
2377 iv: var_iv,
2378 };
2379 }
2380}
2381
2382impl SseDecode for crate::bindings::AesSuccessActionDataDecrypted {
2383 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2385 let mut var_description = <String>::sse_decode(deserializer);
2386 let mut var_plaintext = <String>::sse_decode(deserializer);
2387 return crate::bindings::AesSuccessActionDataDecrypted {
2388 description: var_description,
2389 plaintext: var_plaintext,
2390 };
2391 }
2392}
2393
2394impl SseDecode for crate::bindings::AesSuccessActionDataResult {
2395 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2397 let mut tag_ = <i32>::sse_decode(deserializer);
2398 match tag_ {
2399 0 => {
2400 let mut var_data =
2401 <crate::bindings::AesSuccessActionDataDecrypted>::sse_decode(deserializer);
2402 return crate::bindings::AesSuccessActionDataResult::Decrypted { data: var_data };
2403 }
2404 1 => {
2405 let mut var_reason = <String>::sse_decode(deserializer);
2406 return crate::bindings::AesSuccessActionDataResult::ErrorStatus {
2407 reason: var_reason,
2408 };
2409 }
2410 _ => {
2411 unimplemented!("");
2412 }
2413 }
2414 }
2415}
2416
2417impl SseDecode for crate::bindings::Amount {
2418 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2420 let mut tag_ = <i32>::sse_decode(deserializer);
2421 match tag_ {
2422 0 => {
2423 let mut var_amountMsat = <u64>::sse_decode(deserializer);
2424 return crate::bindings::Amount::Bitcoin {
2425 amount_msat: var_amountMsat,
2426 };
2427 }
2428 1 => {
2429 let mut var_iso4217Code = <String>::sse_decode(deserializer);
2430 let mut var_fractionalAmount = <u64>::sse_decode(deserializer);
2431 return crate::bindings::Amount::Currency {
2432 iso4217_code: var_iso4217Code,
2433 fractional_amount: var_fractionalAmount,
2434 };
2435 }
2436 _ => {
2437 unimplemented!("");
2438 }
2439 }
2440 }
2441}
2442
2443impl SseDecode for crate::model::AssetBalance {
2444 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2446 let mut var_assetId = <String>::sse_decode(deserializer);
2447 let mut var_balanceSat = <u64>::sse_decode(deserializer);
2448 let mut var_name = <Option<String>>::sse_decode(deserializer);
2449 let mut var_ticker = <Option<String>>::sse_decode(deserializer);
2450 let mut var_balance = <Option<f64>>::sse_decode(deserializer);
2451 return crate::model::AssetBalance {
2452 asset_id: var_assetId,
2453 balance_sat: var_balanceSat,
2454 name: var_name,
2455 ticker: var_ticker,
2456 balance: var_balance,
2457 };
2458 }
2459}
2460
2461impl SseDecode for crate::model::AssetInfo {
2462 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2464 let mut var_name = <String>::sse_decode(deserializer);
2465 let mut var_ticker = <String>::sse_decode(deserializer);
2466 let mut var_amount = <f64>::sse_decode(deserializer);
2467 let mut var_fees = <Option<f64>>::sse_decode(deserializer);
2468 return crate::model::AssetInfo {
2469 name: var_name,
2470 ticker: var_ticker,
2471 amount: var_amount,
2472 fees: var_fees,
2473 };
2474 }
2475}
2476
2477impl SseDecode for crate::model::AssetMetadata {
2478 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2480 let mut var_assetId = <String>::sse_decode(deserializer);
2481 let mut var_name = <String>::sse_decode(deserializer);
2482 let mut var_ticker = <String>::sse_decode(deserializer);
2483 let mut var_precision = <u8>::sse_decode(deserializer);
2484 let mut var_fiatId = <Option<String>>::sse_decode(deserializer);
2485 return crate::model::AssetMetadata {
2486 asset_id: var_assetId,
2487 name: var_name,
2488 ticker: var_ticker,
2489 precision: var_precision,
2490 fiat_id: var_fiatId,
2491 };
2492 }
2493}
2494
2495impl SseDecode for crate::model::BackupRequest {
2496 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2498 let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
2499 return crate::model::BackupRequest {
2500 backup_path: var_backupPath,
2501 };
2502 }
2503}
2504
2505impl SseDecode for crate::bindings::BindingEventListener {
2506 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2508 let mut var_stream = <StreamSink<
2509 crate::model::SdkEvent,
2510 flutter_rust_bridge::for_generated::DcoCodec,
2511 >>::sse_decode(deserializer);
2512 return crate::bindings::BindingEventListener { stream: var_stream };
2513 }
2514}
2515
2516impl SseDecode for crate::bindings::BitcoinAddressData {
2517 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2519 let mut var_address = <String>::sse_decode(deserializer);
2520 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2521 let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2522 let mut var_label = <Option<String>>::sse_decode(deserializer);
2523 let mut var_message = <Option<String>>::sse_decode(deserializer);
2524 return crate::bindings::BitcoinAddressData {
2525 address: var_address,
2526 network: var_network,
2527 amount_sat: var_amountSat,
2528 label: var_label,
2529 message: var_message,
2530 };
2531 }
2532}
2533
2534impl SseDecode for crate::model::BlockchainExplorer {
2535 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2537 let mut tag_ = <i32>::sse_decode(deserializer);
2538 match tag_ {
2539 0 => {
2540 let mut var_url = <String>::sse_decode(deserializer);
2541 return crate::model::BlockchainExplorer::Electrum { url: var_url };
2542 }
2543 1 => {
2544 let mut var_url = <String>::sse_decode(deserializer);
2545 let mut var_useWaterfalls = <bool>::sse_decode(deserializer);
2546 return crate::model::BlockchainExplorer::Esplora {
2547 url: var_url,
2548 use_waterfalls: var_useWaterfalls,
2549 };
2550 }
2551 _ => {
2552 unimplemented!("");
2553 }
2554 }
2555 }
2556}
2557
2558impl SseDecode for crate::model::BlockchainInfo {
2559 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2561 let mut var_liquidTip = <u32>::sse_decode(deserializer);
2562 let mut var_bitcoinTip = <u32>::sse_decode(deserializer);
2563 return crate::model::BlockchainInfo {
2564 liquid_tip: var_liquidTip,
2565 bitcoin_tip: var_bitcoinTip,
2566 };
2567 }
2568}
2569
2570impl SseDecode for bool {
2571 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2573 deserializer.cursor.read_u8().unwrap() != 0
2574 }
2575}
2576
2577impl SseDecode for crate::model::BuyBitcoinProvider {
2578 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2580 let mut inner = <i32>::sse_decode(deserializer);
2581 return match inner {
2582 0 => crate::model::BuyBitcoinProvider::Moonpay,
2583 _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", inner),
2584 };
2585 }
2586}
2587
2588impl SseDecode for crate::model::BuyBitcoinRequest {
2589 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2591 let mut var_prepareResponse =
2592 <crate::model::PrepareBuyBitcoinResponse>::sse_decode(deserializer);
2593 let mut var_redirectUrl = <Option<String>>::sse_decode(deserializer);
2594 return crate::model::BuyBitcoinRequest {
2595 prepare_response: var_prepareResponse,
2596 redirect_url: var_redirectUrl,
2597 };
2598 }
2599}
2600
2601impl SseDecode for crate::model::CheckMessageRequest {
2602 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2604 let mut var_message = <String>::sse_decode(deserializer);
2605 let mut var_pubkey = <String>::sse_decode(deserializer);
2606 let mut var_signature = <String>::sse_decode(deserializer);
2607 return crate::model::CheckMessageRequest {
2608 message: var_message,
2609 pubkey: var_pubkey,
2610 signature: var_signature,
2611 };
2612 }
2613}
2614
2615impl SseDecode for crate::model::CheckMessageResponse {
2616 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2618 let mut var_isValid = <bool>::sse_decode(deserializer);
2619 return crate::model::CheckMessageResponse {
2620 is_valid: var_isValid,
2621 };
2622 }
2623}
2624
2625impl SseDecode for crate::model::Config {
2626 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2628 let mut var_liquidExplorer = <crate::model::BlockchainExplorer>::sse_decode(deserializer);
2629 let mut var_bitcoinExplorer = <crate::model::BlockchainExplorer>::sse_decode(deserializer);
2630 let mut var_workingDir = <String>::sse_decode(deserializer);
2631 let mut var_network = <crate::model::LiquidNetwork>::sse_decode(deserializer);
2632 let mut var_paymentTimeoutSec = <u64>::sse_decode(deserializer);
2633 let mut var_syncServiceUrl = <Option<String>>::sse_decode(deserializer);
2634 let mut var_zeroConfMaxAmountSat = <Option<u64>>::sse_decode(deserializer);
2635 let mut var_breezApiKey = <Option<String>>::sse_decode(deserializer);
2636 let mut var_externalInputParsers =
2637 <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_decode(deserializer);
2638 let mut var_useDefaultExternalInputParsers = <bool>::sse_decode(deserializer);
2639 let mut var_onchainFeeRateLeewaySat = <Option<u64>>::sse_decode(deserializer);
2640 let mut var_assetMetadata =
2641 <Option<Vec<crate::model::AssetMetadata>>>::sse_decode(deserializer);
2642 let mut var_sideswapApiKey = <Option<String>>::sse_decode(deserializer);
2643 let mut var_useMagicRoutingHints = <bool>::sse_decode(deserializer);
2644 return crate::model::Config {
2645 liquid_explorer: var_liquidExplorer,
2646 bitcoin_explorer: var_bitcoinExplorer,
2647 working_dir: var_workingDir,
2648 network: var_network,
2649 payment_timeout_sec: var_paymentTimeoutSec,
2650 sync_service_url: var_syncServiceUrl,
2651 zero_conf_max_amount_sat: var_zeroConfMaxAmountSat,
2652 breez_api_key: var_breezApiKey,
2653 external_input_parsers: var_externalInputParsers,
2654 use_default_external_input_parsers: var_useDefaultExternalInputParsers,
2655 onchain_fee_rate_leeway_sat: var_onchainFeeRateLeewaySat,
2656 asset_metadata: var_assetMetadata,
2657 sideswap_api_key: var_sideswapApiKey,
2658 use_magic_routing_hints: var_useMagicRoutingHints,
2659 };
2660 }
2661}
2662
2663impl SseDecode for crate::model::ConnectRequest {
2664 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2666 let mut var_config = <crate::model::Config>::sse_decode(deserializer);
2667 let mut var_mnemonic = <Option<String>>::sse_decode(deserializer);
2668 let mut var_passphrase = <Option<String>>::sse_decode(deserializer);
2669 let mut var_seed = <Option<Vec<u8>>>::sse_decode(deserializer);
2670 return crate::model::ConnectRequest {
2671 config: var_config,
2672 mnemonic: var_mnemonic,
2673 passphrase: var_passphrase,
2674 seed: var_seed,
2675 };
2676 }
2677}
2678
2679impl SseDecode for crate::model::CreateBolt12InvoiceRequest {
2680 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2682 let mut var_offer = <String>::sse_decode(deserializer);
2683 let mut var_invoiceRequest = <String>::sse_decode(deserializer);
2684 return crate::model::CreateBolt12InvoiceRequest {
2685 offer: var_offer,
2686 invoice_request: var_invoiceRequest,
2687 };
2688 }
2689}
2690
2691impl SseDecode for crate::model::CreateBolt12InvoiceResponse {
2692 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2694 let mut var_invoice = <String>::sse_decode(deserializer);
2695 return crate::model::CreateBolt12InvoiceResponse {
2696 invoice: var_invoice,
2697 };
2698 }
2699}
2700
2701impl SseDecode for crate::bindings::CurrencyInfo {
2702 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2704 let mut var_name = <String>::sse_decode(deserializer);
2705 let mut var_fractionSize = <u32>::sse_decode(deserializer);
2706 let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
2707 let mut var_symbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2708 let mut var_uniqSymbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2709 let mut var_localizedName = <Vec<crate::bindings::LocalizedName>>::sse_decode(deserializer);
2710 let mut var_localeOverrides =
2711 <Vec<crate::bindings::LocaleOverrides>>::sse_decode(deserializer);
2712 return crate::bindings::CurrencyInfo {
2713 name: var_name,
2714 fraction_size: var_fractionSize,
2715 spacing: var_spacing,
2716 symbol: var_symbol,
2717 uniq_symbol: var_uniqSymbol,
2718 localized_name: var_localizedName,
2719 locale_overrides: var_localeOverrides,
2720 };
2721 }
2722}
2723
2724impl SseDecode for crate::bindings::ExternalInputParser {
2725 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2727 let mut var_providerId = <String>::sse_decode(deserializer);
2728 let mut var_inputRegex = <String>::sse_decode(deserializer);
2729 let mut var_parserUrl = <String>::sse_decode(deserializer);
2730 return crate::bindings::ExternalInputParser {
2731 provider_id: var_providerId,
2732 input_regex: var_inputRegex,
2733 parser_url: var_parserUrl,
2734 };
2735 }
2736}
2737
2738impl SseDecode for f64 {
2739 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2741 deserializer.cursor.read_f64::<NativeEndian>().unwrap()
2742 }
2743}
2744
2745impl SseDecode for crate::model::FetchPaymentProposedFeesRequest {
2746 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2748 let mut var_swapId = <String>::sse_decode(deserializer);
2749 return crate::model::FetchPaymentProposedFeesRequest {
2750 swap_id: var_swapId,
2751 };
2752 }
2753}
2754
2755impl SseDecode for crate::model::FetchPaymentProposedFeesResponse {
2756 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2758 let mut var_swapId = <String>::sse_decode(deserializer);
2759 let mut var_feesSat = <u64>::sse_decode(deserializer);
2760 let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
2761 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
2762 return crate::model::FetchPaymentProposedFeesResponse {
2763 swap_id: var_swapId,
2764 fees_sat: var_feesSat,
2765 payer_amount_sat: var_payerAmountSat,
2766 receiver_amount_sat: var_receiverAmountSat,
2767 };
2768 }
2769}
2770
2771impl SseDecode for crate::bindings::FiatCurrency {
2772 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2774 let mut var_id = <String>::sse_decode(deserializer);
2775 let mut var_info = <crate::bindings::CurrencyInfo>::sse_decode(deserializer);
2776 return crate::bindings::FiatCurrency {
2777 id: var_id,
2778 info: var_info,
2779 };
2780 }
2781}
2782
2783impl SseDecode for crate::model::GetInfoResponse {
2784 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2786 let mut var_walletInfo = <crate::model::WalletInfo>::sse_decode(deserializer);
2787 let mut var_blockchainInfo = <crate::model::BlockchainInfo>::sse_decode(deserializer);
2788 return crate::model::GetInfoResponse {
2789 wallet_info: var_walletInfo,
2790 blockchain_info: var_blockchainInfo,
2791 };
2792 }
2793}
2794
2795impl SseDecode for crate::model::GetPaymentRequest {
2796 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2798 let mut tag_ = <i32>::sse_decode(deserializer);
2799 match tag_ {
2800 0 => {
2801 let mut var_paymentHash = <String>::sse_decode(deserializer);
2802 return crate::model::GetPaymentRequest::PaymentHash {
2803 payment_hash: var_paymentHash,
2804 };
2805 }
2806 1 => {
2807 let mut var_swapId = <String>::sse_decode(deserializer);
2808 return crate::model::GetPaymentRequest::SwapId {
2809 swap_id: var_swapId,
2810 };
2811 }
2812 _ => {
2813 unimplemented!("");
2814 }
2815 }
2816 }
2817}
2818
2819impl SseDecode for i32 {
2820 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2822 deserializer.cursor.read_i32::<NativeEndian>().unwrap()
2823 }
2824}
2825
2826impl SseDecode for i64 {
2827 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2829 deserializer.cursor.read_i64::<NativeEndian>().unwrap()
2830 }
2831}
2832
2833impl SseDecode for crate::bindings::InputType {
2834 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2836 let mut tag_ = <i32>::sse_decode(deserializer);
2837 match tag_ {
2838 0 => {
2839 let mut var_address =
2840 <crate::bindings::BitcoinAddressData>::sse_decode(deserializer);
2841 return crate::bindings::InputType::BitcoinAddress {
2842 address: var_address,
2843 };
2844 }
2845 1 => {
2846 let mut var_address =
2847 <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
2848 return crate::bindings::InputType::LiquidAddress {
2849 address: var_address,
2850 };
2851 }
2852 2 => {
2853 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
2854 return crate::bindings::InputType::Bolt11 {
2855 invoice: var_invoice,
2856 };
2857 }
2858 3 => {
2859 let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
2860 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2861 return crate::bindings::InputType::Bolt12Offer {
2862 offer: var_offer,
2863 bip353_address: var_bip353Address,
2864 };
2865 }
2866 4 => {
2867 let mut var_nodeId = <String>::sse_decode(deserializer);
2868 return crate::bindings::InputType::NodeId {
2869 node_id: var_nodeId,
2870 };
2871 }
2872 5 => {
2873 let mut var_url = <String>::sse_decode(deserializer);
2874 return crate::bindings::InputType::Url { url: var_url };
2875 }
2876 6 => {
2877 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
2878 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2879 return crate::bindings::InputType::LnUrlPay {
2880 data: var_data,
2881 bip353_address: var_bip353Address,
2882 };
2883 }
2884 7 => {
2885 let mut var_data =
2886 <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
2887 return crate::bindings::InputType::LnUrlWithdraw { data: var_data };
2888 }
2889 8 => {
2890 let mut var_data =
2891 <crate::bindings::LnUrlAuthRequestData>::sse_decode(deserializer);
2892 return crate::bindings::InputType::LnUrlAuth { data: var_data };
2893 }
2894 9 => {
2895 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
2896 return crate::bindings::InputType::LnUrlError { data: var_data };
2897 }
2898 _ => {
2899 unimplemented!("");
2900 }
2901 }
2902 }
2903}
2904
2905impl SseDecode for crate::model::LightningPaymentLimitsResponse {
2906 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2908 let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
2909 let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
2910 return crate::model::LightningPaymentLimitsResponse {
2911 send: var_send,
2912 receive: var_receive,
2913 };
2914 }
2915}
2916
2917impl SseDecode for crate::model::Limits {
2918 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2920 let mut var_minSat = <u64>::sse_decode(deserializer);
2921 let mut var_maxSat = <u64>::sse_decode(deserializer);
2922 let mut var_maxZeroConfSat = <u64>::sse_decode(deserializer);
2923 return crate::model::Limits {
2924 min_sat: var_minSat,
2925 max_sat: var_maxSat,
2926 max_zero_conf_sat: var_maxZeroConfSat,
2927 };
2928 }
2929}
2930
2931impl SseDecode for crate::bindings::LiquidAddressData {
2932 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2934 let mut var_address = <String>::sse_decode(deserializer);
2935 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2936 let mut var_assetId = <Option<String>>::sse_decode(deserializer);
2937 let mut var_amount = <Option<f64>>::sse_decode(deserializer);
2938 let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2939 let mut var_label = <Option<String>>::sse_decode(deserializer);
2940 let mut var_message = <Option<String>>::sse_decode(deserializer);
2941 return crate::bindings::LiquidAddressData {
2942 address: var_address,
2943 network: var_network,
2944 asset_id: var_assetId,
2945 amount: var_amount,
2946 amount_sat: var_amountSat,
2947 label: var_label,
2948 message: var_message,
2949 };
2950 }
2951}
2952
2953impl SseDecode for crate::model::LiquidNetwork {
2954 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2956 let mut inner = <i32>::sse_decode(deserializer);
2957 return match inner {
2958 0 => crate::model::LiquidNetwork::Mainnet,
2959 1 => crate::model::LiquidNetwork::Testnet,
2960 2 => crate::model::LiquidNetwork::Regtest,
2961 _ => unreachable!("Invalid variant for LiquidNetwork: {}", inner),
2962 };
2963 }
2964}
2965
2966impl SseDecode for Vec<String> {
2967 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2969 let mut len_ = <i32>::sse_decode(deserializer);
2970 let mut ans_ = vec![];
2971 for idx_ in 0..len_ {
2972 ans_.push(<String>::sse_decode(deserializer));
2973 }
2974 return ans_;
2975 }
2976}
2977
2978impl SseDecode for Vec<crate::model::AssetBalance> {
2979 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2981 let mut len_ = <i32>::sse_decode(deserializer);
2982 let mut ans_ = vec![];
2983 for idx_ in 0..len_ {
2984 ans_.push(<crate::model::AssetBalance>::sse_decode(deserializer));
2985 }
2986 return ans_;
2987 }
2988}
2989
2990impl SseDecode for Vec<crate::model::AssetMetadata> {
2991 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2993 let mut len_ = <i32>::sse_decode(deserializer);
2994 let mut ans_ = vec![];
2995 for idx_ in 0..len_ {
2996 ans_.push(<crate::model::AssetMetadata>::sse_decode(deserializer));
2997 }
2998 return ans_;
2999 }
3000}
3001
3002impl SseDecode for Vec<crate::bindings::ExternalInputParser> {
3003 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3005 let mut len_ = <i32>::sse_decode(deserializer);
3006 let mut ans_ = vec![];
3007 for idx_ in 0..len_ {
3008 ans_.push(<crate::bindings::ExternalInputParser>::sse_decode(
3009 deserializer,
3010 ));
3011 }
3012 return ans_;
3013 }
3014}
3015
3016impl SseDecode for Vec<crate::bindings::FiatCurrency> {
3017 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3019 let mut len_ = <i32>::sse_decode(deserializer);
3020 let mut ans_ = vec![];
3021 for idx_ in 0..len_ {
3022 ans_.push(<crate::bindings::FiatCurrency>::sse_decode(deserializer));
3023 }
3024 return ans_;
3025 }
3026}
3027
3028impl SseDecode for Vec<crate::bindings::LnOfferBlindedPath> {
3029 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3031 let mut len_ = <i32>::sse_decode(deserializer);
3032 let mut ans_ = vec![];
3033 for idx_ in 0..len_ {
3034 ans_.push(<crate::bindings::LnOfferBlindedPath>::sse_decode(
3035 deserializer,
3036 ));
3037 }
3038 return ans_;
3039 }
3040}
3041
3042impl SseDecode for Vec<crate::bindings::LocaleOverrides> {
3043 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3045 let mut len_ = <i32>::sse_decode(deserializer);
3046 let mut ans_ = vec![];
3047 for idx_ in 0..len_ {
3048 ans_.push(<crate::bindings::LocaleOverrides>::sse_decode(deserializer));
3049 }
3050 return ans_;
3051 }
3052}
3053
3054impl SseDecode for Vec<crate::bindings::LocalizedName> {
3055 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3057 let mut len_ = <i32>::sse_decode(deserializer);
3058 let mut ans_ = vec![];
3059 for idx_ in 0..len_ {
3060 ans_.push(<crate::bindings::LocalizedName>::sse_decode(deserializer));
3061 }
3062 return ans_;
3063 }
3064}
3065
3066impl SseDecode for Vec<crate::model::Payment> {
3067 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3069 let mut len_ = <i32>::sse_decode(deserializer);
3070 let mut ans_ = vec![];
3071 for idx_ in 0..len_ {
3072 ans_.push(<crate::model::Payment>::sse_decode(deserializer));
3073 }
3074 return ans_;
3075 }
3076}
3077
3078impl SseDecode for crate::model::ListPaymentDetails {
3079 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3081 let mut tag_ = <i32>::sse_decode(deserializer);
3082 match tag_ {
3083 0 => {
3084 let mut var_assetId = <Option<String>>::sse_decode(deserializer);
3085 let mut var_destination = <Option<String>>::sse_decode(deserializer);
3086 return crate::model::ListPaymentDetails::Liquid {
3087 asset_id: var_assetId,
3088 destination: var_destination,
3089 };
3090 }
3091 1 => {
3092 let mut var_address = <Option<String>>::sse_decode(deserializer);
3093 return crate::model::ListPaymentDetails::Bitcoin {
3094 address: var_address,
3095 };
3096 }
3097 _ => {
3098 unimplemented!("");
3099 }
3100 }
3101 }
3102}
3103
3104impl SseDecode for Vec<crate::model::PaymentState> {
3105 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3107 let mut len_ = <i32>::sse_decode(deserializer);
3108 let mut ans_ = vec![];
3109 for idx_ in 0..len_ {
3110 ans_.push(<crate::model::PaymentState>::sse_decode(deserializer));
3111 }
3112 return ans_;
3113 }
3114}
3115
3116impl SseDecode for Vec<crate::model::PaymentType> {
3117 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3119 let mut len_ = <i32>::sse_decode(deserializer);
3120 let mut ans_ = vec![];
3121 for idx_ in 0..len_ {
3122 ans_.push(<crate::model::PaymentType>::sse_decode(deserializer));
3123 }
3124 return ans_;
3125 }
3126}
3127
3128impl SseDecode for crate::model::ListPaymentsRequest {
3129 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3131 let mut var_filters = <Option<Vec<crate::model::PaymentType>>>::sse_decode(deserializer);
3132 let mut var_states = <Option<Vec<crate::model::PaymentState>>>::sse_decode(deserializer);
3133 let mut var_fromTimestamp = <Option<i64>>::sse_decode(deserializer);
3134 let mut var_toTimestamp = <Option<i64>>::sse_decode(deserializer);
3135 let mut var_offset = <Option<u32>>::sse_decode(deserializer);
3136 let mut var_limit = <Option<u32>>::sse_decode(deserializer);
3137 let mut var_details = <Option<crate::model::ListPaymentDetails>>::sse_decode(deserializer);
3138 let mut var_sortAscending = <Option<bool>>::sse_decode(deserializer);
3139 return crate::model::ListPaymentsRequest {
3140 filters: var_filters,
3141 states: var_states,
3142 from_timestamp: var_fromTimestamp,
3143 to_timestamp: var_toTimestamp,
3144 offset: var_offset,
3145 limit: var_limit,
3146 details: var_details,
3147 sort_ascending: var_sortAscending,
3148 };
3149 }
3150}
3151
3152impl SseDecode for Vec<u8> {
3153 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3155 let mut len_ = <i32>::sse_decode(deserializer);
3156 let mut ans_ = vec![];
3157 for idx_ in 0..len_ {
3158 ans_.push(<u8>::sse_decode(deserializer));
3159 }
3160 return ans_;
3161 }
3162}
3163
3164impl SseDecode for Vec<crate::bindings::Rate> {
3165 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3167 let mut len_ = <i32>::sse_decode(deserializer);
3168 let mut ans_ = vec![];
3169 for idx_ in 0..len_ {
3170 ans_.push(<crate::bindings::Rate>::sse_decode(deserializer));
3171 }
3172 return ans_;
3173 }
3174}
3175
3176impl SseDecode for Vec<crate::model::RefundableSwap> {
3177 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3179 let mut len_ = <i32>::sse_decode(deserializer);
3180 let mut ans_ = vec![];
3181 for idx_ in 0..len_ {
3182 ans_.push(<crate::model::RefundableSwap>::sse_decode(deserializer));
3183 }
3184 return ans_;
3185 }
3186}
3187
3188impl SseDecode for Vec<crate::bindings::RouteHint> {
3189 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3191 let mut len_ = <i32>::sse_decode(deserializer);
3192 let mut ans_ = vec![];
3193 for idx_ in 0..len_ {
3194 ans_.push(<crate::bindings::RouteHint>::sse_decode(deserializer));
3195 }
3196 return ans_;
3197 }
3198}
3199
3200impl SseDecode for Vec<crate::bindings::RouteHintHop> {
3201 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3203 let mut len_ = <i32>::sse_decode(deserializer);
3204 let mut ans_ = vec![];
3205 for idx_ in 0..len_ {
3206 ans_.push(<crate::bindings::RouteHintHop>::sse_decode(deserializer));
3207 }
3208 return ans_;
3209 }
3210}
3211
3212impl SseDecode for crate::bindings::LNInvoice {
3213 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3215 let mut var_bolt11 = <String>::sse_decode(deserializer);
3216 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
3217 let mut var_payeePubkey = <String>::sse_decode(deserializer);
3218 let mut var_paymentHash = <String>::sse_decode(deserializer);
3219 let mut var_description = <Option<String>>::sse_decode(deserializer);
3220 let mut var_descriptionHash = <Option<String>>::sse_decode(deserializer);
3221 let mut var_amountMsat = <Option<u64>>::sse_decode(deserializer);
3222 let mut var_timestamp = <u64>::sse_decode(deserializer);
3223 let mut var_expiry = <u64>::sse_decode(deserializer);
3224 let mut var_routingHints = <Vec<crate::bindings::RouteHint>>::sse_decode(deserializer);
3225 let mut var_paymentSecret = <Vec<u8>>::sse_decode(deserializer);
3226 let mut var_minFinalCltvExpiryDelta = <u64>::sse_decode(deserializer);
3227 return crate::bindings::LNInvoice {
3228 bolt11: var_bolt11,
3229 network: var_network,
3230 payee_pubkey: var_payeePubkey,
3231 payment_hash: var_paymentHash,
3232 description: var_description,
3233 description_hash: var_descriptionHash,
3234 amount_msat: var_amountMsat,
3235 timestamp: var_timestamp,
3236 expiry: var_expiry,
3237 routing_hints: var_routingHints,
3238 payment_secret: var_paymentSecret,
3239 min_final_cltv_expiry_delta: var_minFinalCltvExpiryDelta,
3240 };
3241 }
3242}
3243
3244impl SseDecode for crate::bindings::LNOffer {
3245 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3247 let mut var_offer = <String>::sse_decode(deserializer);
3248 let mut var_chains = <Vec<String>>::sse_decode(deserializer);
3249 let mut var_minAmount = <Option<crate::bindings::Amount>>::sse_decode(deserializer);
3250 let mut var_description = <Option<String>>::sse_decode(deserializer);
3251 let mut var_absoluteExpiry = <Option<u64>>::sse_decode(deserializer);
3252 let mut var_issuer = <Option<String>>::sse_decode(deserializer);
3253 let mut var_signingPubkey = <Option<String>>::sse_decode(deserializer);
3254 let mut var_paths = <Vec<crate::bindings::LnOfferBlindedPath>>::sse_decode(deserializer);
3255 return crate::bindings::LNOffer {
3256 offer: var_offer,
3257 chains: var_chains,
3258 min_amount: var_minAmount,
3259 description: var_description,
3260 absolute_expiry: var_absoluteExpiry,
3261 issuer: var_issuer,
3262 signing_pubkey: var_signingPubkey,
3263 paths: var_paths,
3264 };
3265 }
3266}
3267
3268impl SseDecode for crate::bindings::LnOfferBlindedPath {
3269 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3271 let mut var_blindedHops = <Vec<String>>::sse_decode(deserializer);
3272 return crate::bindings::LnOfferBlindedPath {
3273 blinded_hops: var_blindedHops,
3274 };
3275 }
3276}
3277
3278impl SseDecode for crate::bindings::duplicates::LnUrlAuthError {
3279 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3281 let mut tag_ = <i32>::sse_decode(deserializer);
3282 match tag_ {
3283 0 => {
3284 let mut var_err = <String>::sse_decode(deserializer);
3285 return crate::bindings::duplicates::LnUrlAuthError::Generic { err: var_err };
3286 }
3287 1 => {
3288 let mut var_err = <String>::sse_decode(deserializer);
3289 return crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err: var_err };
3290 }
3291 2 => {
3292 let mut var_err = <String>::sse_decode(deserializer);
3293 return crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
3294 err: var_err,
3295 };
3296 }
3297 _ => {
3298 unimplemented!("");
3299 }
3300 }
3301 }
3302}
3303
3304impl SseDecode for crate::bindings::LnUrlAuthRequestData {
3305 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3307 let mut var_k1 = <String>::sse_decode(deserializer);
3308 let mut var_action = <Option<String>>::sse_decode(deserializer);
3309 let mut var_domain = <String>::sse_decode(deserializer);
3310 let mut var_url = <String>::sse_decode(deserializer);
3311 return crate::bindings::LnUrlAuthRequestData {
3312 k1: var_k1,
3313 action: var_action,
3314 domain: var_domain,
3315 url: var_url,
3316 };
3317 }
3318}
3319
3320impl SseDecode for crate::bindings::duplicates::LnUrlCallbackStatus {
3321 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3323 let mut tag_ = <i32>::sse_decode(deserializer);
3324 match tag_ {
3325 0 => {
3326 return crate::bindings::duplicates::LnUrlCallbackStatus::Ok;
3327 }
3328 1 => {
3329 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3330 return crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
3331 data: var_data,
3332 };
3333 }
3334 _ => {
3335 unimplemented!("");
3336 }
3337 }
3338 }
3339}
3340
3341impl SseDecode for crate::bindings::LnUrlErrorData {
3342 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3344 let mut var_reason = <String>::sse_decode(deserializer);
3345 return crate::bindings::LnUrlErrorData { reason: var_reason };
3346 }
3347}
3348
3349impl SseDecode for crate::model::LnUrlInfo {
3350 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3352 let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3353 let mut var_lnurlPayComment = <Option<String>>::sse_decode(deserializer);
3354 let mut var_lnurlPayDomain = <Option<String>>::sse_decode(deserializer);
3355 let mut var_lnurlPayMetadata = <Option<String>>::sse_decode(deserializer);
3356 let mut var_lnurlPaySuccessAction =
3357 <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3358 let mut var_lnurlPayUnprocessedSuccessAction =
3359 <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
3360 let mut var_lnurlWithdrawEndpoint = <Option<String>>::sse_decode(deserializer);
3361 return crate::model::LnUrlInfo {
3362 ln_address: var_lnAddress,
3363 lnurl_pay_comment: var_lnurlPayComment,
3364 lnurl_pay_domain: var_lnurlPayDomain,
3365 lnurl_pay_metadata: var_lnurlPayMetadata,
3366 lnurl_pay_success_action: var_lnurlPaySuccessAction,
3367 lnurl_pay_unprocessed_success_action: var_lnurlPayUnprocessedSuccessAction,
3368 lnurl_withdraw_endpoint: var_lnurlWithdrawEndpoint,
3369 };
3370 }
3371}
3372
3373impl SseDecode for crate::bindings::duplicates::LnUrlPayError {
3374 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3376 let mut tag_ = <i32>::sse_decode(deserializer);
3377 match tag_ {
3378 0 => {
3379 return crate::bindings::duplicates::LnUrlPayError::AlreadyPaid;
3380 }
3381 1 => {
3382 let mut var_err = <String>::sse_decode(deserializer);
3383 return crate::bindings::duplicates::LnUrlPayError::Generic { err: var_err };
3384 }
3385 2 => {
3386 let mut var_err = <String>::sse_decode(deserializer);
3387 return crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
3388 err: var_err,
3389 };
3390 }
3391 3 => {
3392 let mut var_err = <String>::sse_decode(deserializer);
3393 return crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err: var_err };
3394 }
3395 4 => {
3396 let mut var_err = <String>::sse_decode(deserializer);
3397 return crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err: var_err };
3398 }
3399 5 => {
3400 let mut var_err = <String>::sse_decode(deserializer);
3401 return crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err: var_err };
3402 }
3403 6 => {
3404 let mut var_err = <String>::sse_decode(deserializer);
3405 return crate::bindings::duplicates::LnUrlPayError::InvalidUri { err: var_err };
3406 }
3407 7 => {
3408 let mut var_err = <String>::sse_decode(deserializer);
3409 return crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err: var_err };
3410 }
3411 8 => {
3412 let mut var_err = <String>::sse_decode(deserializer);
3413 return crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err: var_err };
3414 }
3415 9 => {
3416 let mut var_err = <String>::sse_decode(deserializer);
3417 return crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err: var_err };
3418 }
3419 10 => {
3420 let mut var_err = <String>::sse_decode(deserializer);
3421 return crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err: var_err };
3422 }
3423 11 => {
3424 let mut var_err = <String>::sse_decode(deserializer);
3425 return crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
3426 err: var_err,
3427 };
3428 }
3429 12 => {
3430 let mut var_err = <String>::sse_decode(deserializer);
3431 return crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
3432 err: var_err,
3433 };
3434 }
3435 _ => {
3436 unimplemented!("");
3437 }
3438 }
3439 }
3440}
3441
3442impl SseDecode for crate::bindings::LnUrlPayErrorData {
3443 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3445 let mut var_paymentHash = <String>::sse_decode(deserializer);
3446 let mut var_reason = <String>::sse_decode(deserializer);
3447 return crate::bindings::LnUrlPayErrorData {
3448 payment_hash: var_paymentHash,
3449 reason: var_reason,
3450 };
3451 }
3452}
3453
3454impl SseDecode for crate::model::LnUrlPayRequest {
3455 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3457 let mut var_prepareResponse =
3458 <crate::model::PrepareLnUrlPayResponse>::sse_decode(deserializer);
3459 return crate::model::LnUrlPayRequest {
3460 prepare_response: var_prepareResponse,
3461 };
3462 }
3463}
3464
3465impl SseDecode for crate::bindings::LnUrlPayRequestData {
3466 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3468 let mut var_callback = <String>::sse_decode(deserializer);
3469 let mut var_minSendable = <u64>::sse_decode(deserializer);
3470 let mut var_maxSendable = <u64>::sse_decode(deserializer);
3471 let mut var_metadataStr = <String>::sse_decode(deserializer);
3472 let mut var_commentAllowed = <u16>::sse_decode(deserializer);
3473 let mut var_domain = <String>::sse_decode(deserializer);
3474 let mut var_allowsNostr = <bool>::sse_decode(deserializer);
3475 let mut var_nostrPubkey = <Option<String>>::sse_decode(deserializer);
3476 let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3477 return crate::bindings::LnUrlPayRequestData {
3478 callback: var_callback,
3479 min_sendable: var_minSendable,
3480 max_sendable: var_maxSendable,
3481 metadata_str: var_metadataStr,
3482 comment_allowed: var_commentAllowed,
3483 domain: var_domain,
3484 allows_nostr: var_allowsNostr,
3485 nostr_pubkey: var_nostrPubkey,
3486 ln_address: var_lnAddress,
3487 };
3488 }
3489}
3490
3491impl SseDecode for crate::model::LnUrlPayResult {
3492 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3494 let mut tag_ = <i32>::sse_decode(deserializer);
3495 match tag_ {
3496 0 => {
3497 let mut var_data = <crate::model::LnUrlPaySuccessData>::sse_decode(deserializer);
3498 return crate::model::LnUrlPayResult::EndpointSuccess { data: var_data };
3499 }
3500 1 => {
3501 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3502 return crate::model::LnUrlPayResult::EndpointError { data: var_data };
3503 }
3504 2 => {
3505 let mut var_data = <crate::bindings::LnUrlPayErrorData>::sse_decode(deserializer);
3506 return crate::model::LnUrlPayResult::PayError { data: var_data };
3507 }
3508 _ => {
3509 unimplemented!("");
3510 }
3511 }
3512 }
3513}
3514
3515impl SseDecode for crate::model::LnUrlPaySuccessData {
3516 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3518 let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
3519 let mut var_successAction =
3520 <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3521 return crate::model::LnUrlPaySuccessData {
3522 payment: var_payment,
3523 success_action: var_successAction,
3524 };
3525 }
3526}
3527
3528impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawError {
3529 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3531 let mut tag_ = <i32>::sse_decode(deserializer);
3532 match tag_ {
3533 0 => {
3534 let mut var_err = <String>::sse_decode(deserializer);
3535 return crate::bindings::duplicates::LnUrlWithdrawError::Generic { err: var_err };
3536 }
3537 1 => {
3538 let mut var_err = <String>::sse_decode(deserializer);
3539 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
3540 err: var_err,
3541 };
3542 }
3543 2 => {
3544 let mut var_err = <String>::sse_decode(deserializer);
3545 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
3546 err: var_err,
3547 };
3548 }
3549 3 => {
3550 let mut var_err = <String>::sse_decode(deserializer);
3551 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
3552 err: var_err,
3553 };
3554 }
3555 4 => {
3556 let mut var_err = <String>::sse_decode(deserializer);
3557 return crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
3558 err: var_err,
3559 };
3560 }
3561 5 => {
3562 let mut var_err = <String>::sse_decode(deserializer);
3563 return crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
3564 err: var_err,
3565 };
3566 }
3567 _ => {
3568 unimplemented!("");
3569 }
3570 }
3571 }
3572}
3573
3574impl SseDecode for crate::bindings::LnUrlWithdrawRequest {
3575 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3577 let mut var_data = <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
3578 let mut var_amountMsat = <u64>::sse_decode(deserializer);
3579 let mut var_description = <Option<String>>::sse_decode(deserializer);
3580 return crate::bindings::LnUrlWithdrawRequest {
3581 data: var_data,
3582 amount_msat: var_amountMsat,
3583 description: var_description,
3584 };
3585 }
3586}
3587
3588impl SseDecode for crate::bindings::LnUrlWithdrawRequestData {
3589 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3591 let mut var_callback = <String>::sse_decode(deserializer);
3592 let mut var_k1 = <String>::sse_decode(deserializer);
3593 let mut var_defaultDescription = <String>::sse_decode(deserializer);
3594 let mut var_minWithdrawable = <u64>::sse_decode(deserializer);
3595 let mut var_maxWithdrawable = <u64>::sse_decode(deserializer);
3596 return crate::bindings::LnUrlWithdrawRequestData {
3597 callback: var_callback,
3598 k1: var_k1,
3599 default_description: var_defaultDescription,
3600 min_withdrawable: var_minWithdrawable,
3601 max_withdrawable: var_maxWithdrawable,
3602 };
3603 }
3604}
3605
3606impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawResult {
3607 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3609 let mut tag_ = <i32>::sse_decode(deserializer);
3610 match tag_ {
3611 0 => {
3612 let mut var_data =
3613 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3614 deserializer,
3615 );
3616 return crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data: var_data };
3617 }
3618 1 => {
3619 let mut var_data =
3620 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3621 deserializer,
3622 );
3623 return crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
3624 data: var_data,
3625 };
3626 }
3627 2 => {
3628 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3629 return crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
3630 data: var_data,
3631 };
3632 }
3633 _ => {
3634 unimplemented!("");
3635 }
3636 }
3637 }
3638}
3639
3640impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3641 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3643 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
3644 return crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3645 invoice: var_invoice,
3646 };
3647 }
3648}
3649
3650impl SseDecode for crate::bindings::LocaleOverrides {
3651 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3653 let mut var_locale = <String>::sse_decode(deserializer);
3654 let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
3655 let mut var_symbol = <crate::bindings::Symbol>::sse_decode(deserializer);
3656 return crate::bindings::LocaleOverrides {
3657 locale: var_locale,
3658 spacing: var_spacing,
3659 symbol: var_symbol,
3660 };
3661 }
3662}
3663
3664impl SseDecode for crate::bindings::LocalizedName {
3665 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3667 let mut var_locale = <String>::sse_decode(deserializer);
3668 let mut var_name = <String>::sse_decode(deserializer);
3669 return crate::bindings::LocalizedName {
3670 locale: var_locale,
3671 name: var_name,
3672 };
3673 }
3674}
3675
3676impl SseDecode for crate::model::LogEntry {
3677 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3679 let mut var_line = <String>::sse_decode(deserializer);
3680 let mut var_level = <String>::sse_decode(deserializer);
3681 return crate::model::LogEntry {
3682 line: var_line,
3683 level: var_level,
3684 };
3685 }
3686}
3687
3688impl SseDecode for crate::bindings::MessageSuccessActionData {
3689 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3691 let mut var_message = <String>::sse_decode(deserializer);
3692 return crate::bindings::MessageSuccessActionData {
3693 message: var_message,
3694 };
3695 }
3696}
3697
3698impl SseDecode for crate::bindings::Network {
3699 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3701 let mut inner = <i32>::sse_decode(deserializer);
3702 return match inner {
3703 0 => crate::bindings::Network::Bitcoin,
3704 1 => crate::bindings::Network::Testnet,
3705 2 => crate::bindings::Network::Signet,
3706 3 => crate::bindings::Network::Regtest,
3707 _ => unreachable!("Invalid variant for Network: {}", inner),
3708 };
3709 }
3710}
3711
3712impl SseDecode for crate::model::OnchainPaymentLimitsResponse {
3713 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3715 let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
3716 let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
3717 return crate::model::OnchainPaymentLimitsResponse {
3718 send: var_send,
3719 receive: var_receive,
3720 };
3721 }
3722}
3723
3724impl SseDecode for Option<String> {
3725 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3727 if (<bool>::sse_decode(deserializer)) {
3728 return Some(<String>::sse_decode(deserializer));
3729 } else {
3730 return None;
3731 }
3732 }
3733}
3734
3735impl SseDecode for Option<crate::bindings::Amount> {
3736 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3738 if (<bool>::sse_decode(deserializer)) {
3739 return Some(<crate::bindings::Amount>::sse_decode(deserializer));
3740 } else {
3741 return None;
3742 }
3743 }
3744}
3745
3746impl SseDecode for Option<crate::model::AssetInfo> {
3747 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3749 if (<bool>::sse_decode(deserializer)) {
3750 return Some(<crate::model::AssetInfo>::sse_decode(deserializer));
3751 } else {
3752 return None;
3753 }
3754 }
3755}
3756
3757impl SseDecode for Option<bool> {
3758 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3760 if (<bool>::sse_decode(deserializer)) {
3761 return Some(<bool>::sse_decode(deserializer));
3762 } else {
3763 return None;
3764 }
3765 }
3766}
3767
3768impl SseDecode for Option<f64> {
3769 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3771 if (<bool>::sse_decode(deserializer)) {
3772 return Some(<f64>::sse_decode(deserializer));
3773 } else {
3774 return None;
3775 }
3776 }
3777}
3778
3779impl SseDecode for Option<i64> {
3780 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3782 if (<bool>::sse_decode(deserializer)) {
3783 return Some(<i64>::sse_decode(deserializer));
3784 } else {
3785 return None;
3786 }
3787 }
3788}
3789
3790impl SseDecode for Option<crate::model::ListPaymentDetails> {
3791 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3793 if (<bool>::sse_decode(deserializer)) {
3794 return Some(<crate::model::ListPaymentDetails>::sse_decode(deserializer));
3795 } else {
3796 return None;
3797 }
3798 }
3799}
3800
3801impl SseDecode for Option<crate::model::LnUrlInfo> {
3802 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3804 if (<bool>::sse_decode(deserializer)) {
3805 return Some(<crate::model::LnUrlInfo>::sse_decode(deserializer));
3806 } else {
3807 return None;
3808 }
3809 }
3810}
3811
3812impl SseDecode for Option<crate::model::PayAmount> {
3813 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3815 if (<bool>::sse_decode(deserializer)) {
3816 return Some(<crate::model::PayAmount>::sse_decode(deserializer));
3817 } else {
3818 return None;
3819 }
3820 }
3821}
3822
3823impl SseDecode for Option<crate::model::Payment> {
3824 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3826 if (<bool>::sse_decode(deserializer)) {
3827 return Some(<crate::model::Payment>::sse_decode(deserializer));
3828 } else {
3829 return None;
3830 }
3831 }
3832}
3833
3834impl SseDecode for Option<crate::model::ReceiveAmount> {
3835 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3837 if (<bool>::sse_decode(deserializer)) {
3838 return Some(<crate::model::ReceiveAmount>::sse_decode(deserializer));
3839 } else {
3840 return None;
3841 }
3842 }
3843}
3844
3845impl SseDecode for Option<crate::bindings::SuccessAction> {
3846 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3848 if (<bool>::sse_decode(deserializer)) {
3849 return Some(<crate::bindings::SuccessAction>::sse_decode(deserializer));
3850 } else {
3851 return None;
3852 }
3853 }
3854}
3855
3856impl SseDecode for Option<crate::bindings::SuccessActionProcessed> {
3857 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3859 if (<bool>::sse_decode(deserializer)) {
3860 return Some(<crate::bindings::SuccessActionProcessed>::sse_decode(
3861 deserializer,
3862 ));
3863 } else {
3864 return None;
3865 }
3866 }
3867}
3868
3869impl SseDecode for Option<crate::bindings::Symbol> {
3870 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3872 if (<bool>::sse_decode(deserializer)) {
3873 return Some(<crate::bindings::Symbol>::sse_decode(deserializer));
3874 } else {
3875 return None;
3876 }
3877 }
3878}
3879
3880impl SseDecode for Option<u32> {
3881 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3883 if (<bool>::sse_decode(deserializer)) {
3884 return Some(<u32>::sse_decode(deserializer));
3885 } else {
3886 return None;
3887 }
3888 }
3889}
3890
3891impl SseDecode for Option<u64> {
3892 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3894 if (<bool>::sse_decode(deserializer)) {
3895 return Some(<u64>::sse_decode(deserializer));
3896 } else {
3897 return None;
3898 }
3899 }
3900}
3901
3902impl SseDecode for Option<Vec<crate::model::AssetMetadata>> {
3903 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3905 if (<bool>::sse_decode(deserializer)) {
3906 return Some(<Vec<crate::model::AssetMetadata>>::sse_decode(deserializer));
3907 } else {
3908 return None;
3909 }
3910 }
3911}
3912
3913impl SseDecode for Option<Vec<crate::bindings::ExternalInputParser>> {
3914 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3916 if (<bool>::sse_decode(deserializer)) {
3917 return Some(<Vec<crate::bindings::ExternalInputParser>>::sse_decode(
3918 deserializer,
3919 ));
3920 } else {
3921 return None;
3922 }
3923 }
3924}
3925
3926impl SseDecode for Option<Vec<crate::model::PaymentState>> {
3927 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3929 if (<bool>::sse_decode(deserializer)) {
3930 return Some(<Vec<crate::model::PaymentState>>::sse_decode(deserializer));
3931 } else {
3932 return None;
3933 }
3934 }
3935}
3936
3937impl SseDecode for Option<Vec<crate::model::PaymentType>> {
3938 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3940 if (<bool>::sse_decode(deserializer)) {
3941 return Some(<Vec<crate::model::PaymentType>>::sse_decode(deserializer));
3942 } else {
3943 return None;
3944 }
3945 }
3946}
3947
3948impl SseDecode for Option<Vec<u8>> {
3949 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3951 if (<bool>::sse_decode(deserializer)) {
3952 return Some(<Vec<u8>>::sse_decode(deserializer));
3953 } else {
3954 return None;
3955 }
3956 }
3957}
3958
3959impl SseDecode for crate::model::PayAmount {
3960 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3962 let mut tag_ = <i32>::sse_decode(deserializer);
3963 match tag_ {
3964 0 => {
3965 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
3966 return crate::model::PayAmount::Bitcoin {
3967 receiver_amount_sat: var_receiverAmountSat,
3968 };
3969 }
3970 1 => {
3971 let mut var_toAsset = <String>::sse_decode(deserializer);
3972 let mut var_receiverAmount = <f64>::sse_decode(deserializer);
3973 let mut var_estimateAssetFees = <Option<bool>>::sse_decode(deserializer);
3974 let mut var_fromAsset = <Option<String>>::sse_decode(deserializer);
3975 return crate::model::PayAmount::Asset {
3976 to_asset: var_toAsset,
3977 receiver_amount: var_receiverAmount,
3978 estimate_asset_fees: var_estimateAssetFees,
3979 from_asset: var_fromAsset,
3980 };
3981 }
3982 2 => {
3983 return crate::model::PayAmount::Drain;
3984 }
3985 _ => {
3986 unimplemented!("");
3987 }
3988 }
3989 }
3990}
3991
3992impl SseDecode for crate::model::PayOnchainRequest {
3993 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3995 let mut var_address = <String>::sse_decode(deserializer);
3996 let mut var_prepareResponse =
3997 <crate::model::PreparePayOnchainResponse>::sse_decode(deserializer);
3998 return crate::model::PayOnchainRequest {
3999 address: var_address,
4000 prepare_response: var_prepareResponse,
4001 };
4002 }
4003}
4004
4005impl SseDecode for crate::model::Payment {
4006 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4008 let mut var_destination = <Option<String>>::sse_decode(deserializer);
4009 let mut var_txId = <Option<String>>::sse_decode(deserializer);
4010 let mut var_unblindingData = <Option<String>>::sse_decode(deserializer);
4011 let mut var_timestamp = <u32>::sse_decode(deserializer);
4012 let mut var_amountSat = <u64>::sse_decode(deserializer);
4013 let mut var_feesSat = <u64>::sse_decode(deserializer);
4014 let mut var_swapperFeesSat = <Option<u64>>::sse_decode(deserializer);
4015 let mut var_paymentType = <crate::model::PaymentType>::sse_decode(deserializer);
4016 let mut var_status = <crate::model::PaymentState>::sse_decode(deserializer);
4017 let mut var_details = <crate::model::PaymentDetails>::sse_decode(deserializer);
4018 return crate::model::Payment {
4019 destination: var_destination,
4020 tx_id: var_txId,
4021 unblinding_data: var_unblindingData,
4022 timestamp: var_timestamp,
4023 amount_sat: var_amountSat,
4024 fees_sat: var_feesSat,
4025 swapper_fees_sat: var_swapperFeesSat,
4026 payment_type: var_paymentType,
4027 status: var_status,
4028 details: var_details,
4029 };
4030 }
4031}
4032
4033impl SseDecode for crate::model::PaymentDetails {
4034 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4036 let mut tag_ = <i32>::sse_decode(deserializer);
4037 match tag_ {
4038 0 => {
4039 let mut var_swapId = <String>::sse_decode(deserializer);
4040 let mut var_description = <String>::sse_decode(deserializer);
4041 let mut var_liquidExpirationBlockheight = <u32>::sse_decode(deserializer);
4042 let mut var_preimage = <Option<String>>::sse_decode(deserializer);
4043 let mut var_invoice = <Option<String>>::sse_decode(deserializer);
4044 let mut var_bolt12Offer = <Option<String>>::sse_decode(deserializer);
4045 let mut var_paymentHash = <Option<String>>::sse_decode(deserializer);
4046 let mut var_destinationPubkey = <Option<String>>::sse_decode(deserializer);
4047 let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4048 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4049 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4050 let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4051 let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4052 let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4053 return crate::model::PaymentDetails::Lightning {
4054 swap_id: var_swapId,
4055 description: var_description,
4056 liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4057 preimage: var_preimage,
4058 invoice: var_invoice,
4059 bolt12_offer: var_bolt12Offer,
4060 payment_hash: var_paymentHash,
4061 destination_pubkey: var_destinationPubkey,
4062 lnurl_info: var_lnurlInfo,
4063 bip353_address: var_bip353Address,
4064 payer_note: var_payerNote,
4065 claim_tx_id: var_claimTxId,
4066 refund_tx_id: var_refundTxId,
4067 refund_tx_amount_sat: var_refundTxAmountSat,
4068 };
4069 }
4070 1 => {
4071 let mut var_destination = <String>::sse_decode(deserializer);
4072 let mut var_description = <String>::sse_decode(deserializer);
4073 let mut var_assetId = <String>::sse_decode(deserializer);
4074 let mut var_assetInfo = <Option<crate::model::AssetInfo>>::sse_decode(deserializer);
4075 let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4076 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4077 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4078 return crate::model::PaymentDetails::Liquid {
4079 destination: var_destination,
4080 description: var_description,
4081 asset_id: var_assetId,
4082 asset_info: var_assetInfo,
4083 lnurl_info: var_lnurlInfo,
4084 bip353_address: var_bip353Address,
4085 payer_note: var_payerNote,
4086 };
4087 }
4088 2 => {
4089 let mut var_swapId = <String>::sse_decode(deserializer);
4090 let mut var_bitcoinAddress = <String>::sse_decode(deserializer);
4091 let mut var_description = <String>::sse_decode(deserializer);
4092 let mut var_autoAcceptedFees = <bool>::sse_decode(deserializer);
4093 let mut var_liquidExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4094 let mut var_bitcoinExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4095 let mut var_lockupTxId = <Option<String>>::sse_decode(deserializer);
4096 let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4097 let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4098 let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4099 return crate::model::PaymentDetails::Bitcoin {
4100 swap_id: var_swapId,
4101 bitcoin_address: var_bitcoinAddress,
4102 description: var_description,
4103 auto_accepted_fees: var_autoAcceptedFees,
4104 liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4105 bitcoin_expiration_blockheight: var_bitcoinExpirationBlockheight,
4106 lockup_tx_id: var_lockupTxId,
4107 claim_tx_id: var_claimTxId,
4108 refund_tx_id: var_refundTxId,
4109 refund_tx_amount_sat: var_refundTxAmountSat,
4110 };
4111 }
4112 _ => {
4113 unimplemented!("");
4114 }
4115 }
4116 }
4117}
4118
4119impl SseDecode for crate::error::PaymentError {
4120 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4122 let mut tag_ = <i32>::sse_decode(deserializer);
4123 match tag_ {
4124 0 => {
4125 return crate::error::PaymentError::AlreadyClaimed;
4126 }
4127 1 => {
4128 return crate::error::PaymentError::AlreadyPaid;
4129 }
4130 2 => {
4131 return crate::error::PaymentError::PaymentInProgress;
4132 }
4133 3 => {
4134 let mut var_min = <u64>::sse_decode(deserializer);
4135 let mut var_max = <u64>::sse_decode(deserializer);
4136 return crate::error::PaymentError::AmountOutOfRange {
4137 min: var_min,
4138 max: var_max,
4139 };
4140 }
4141 4 => {
4142 let mut var_err = <String>::sse_decode(deserializer);
4143 return crate::error::PaymentError::AmountMissing { err: var_err };
4144 }
4145 5 => {
4146 let mut var_err = <String>::sse_decode(deserializer);
4147 return crate::error::PaymentError::AssetError { err: var_err };
4148 }
4149 6 => {
4150 let mut var_err = <String>::sse_decode(deserializer);
4151 return crate::error::PaymentError::InvalidNetwork { err: var_err };
4152 }
4153 7 => {
4154 let mut var_err = <String>::sse_decode(deserializer);
4155 return crate::error::PaymentError::Generic { err: var_err };
4156 }
4157 8 => {
4158 return crate::error::PaymentError::InvalidOrExpiredFees;
4159 }
4160 9 => {
4161 return crate::error::PaymentError::InsufficientFunds;
4162 }
4163 10 => {
4164 let mut var_err = <String>::sse_decode(deserializer);
4165 return crate::error::PaymentError::InvalidDescription { err: var_err };
4166 }
4167 11 => {
4168 let mut var_err = <String>::sse_decode(deserializer);
4169 return crate::error::PaymentError::InvalidInvoice { err: var_err };
4170 }
4171 12 => {
4172 return crate::error::PaymentError::InvalidPreimage;
4173 }
4174 13 => {
4175 return crate::error::PaymentError::PairsNotFound;
4176 }
4177 14 => {
4178 return crate::error::PaymentError::PaymentTimeout;
4179 }
4180 15 => {
4181 return crate::error::PaymentError::PersistError;
4182 }
4183 16 => {
4184 let mut var_err = <String>::sse_decode(deserializer);
4185 return crate::error::PaymentError::ReceiveError { err: var_err };
4186 }
4187 17 => {
4188 let mut var_err = <String>::sse_decode(deserializer);
4189 let mut var_refundTxId = <String>::sse_decode(deserializer);
4190 return crate::error::PaymentError::Refunded {
4191 err: var_err,
4192 refund_tx_id: var_refundTxId,
4193 };
4194 }
4195 18 => {
4196 return crate::error::PaymentError::SelfTransferNotSupported;
4197 }
4198 19 => {
4199 let mut var_err = <String>::sse_decode(deserializer);
4200 return crate::error::PaymentError::SendError { err: var_err };
4201 }
4202 20 => {
4203 let mut var_err = <String>::sse_decode(deserializer);
4204 return crate::error::PaymentError::SignerError { err: var_err };
4205 }
4206 _ => {
4207 unimplemented!("");
4208 }
4209 }
4210 }
4211}
4212
4213impl SseDecode for crate::model::PaymentMethod {
4214 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4216 let mut inner = <i32>::sse_decode(deserializer);
4217 return match inner {
4218 0 => crate::model::PaymentMethod::Lightning,
4219 1 => crate::model::PaymentMethod::Bolt11Invoice,
4220 2 => crate::model::PaymentMethod::Bolt12Offer,
4221 3 => crate::model::PaymentMethod::BitcoinAddress,
4222 4 => crate::model::PaymentMethod::LiquidAddress,
4223 _ => unreachable!("Invalid variant for PaymentMethod: {}", inner),
4224 };
4225 }
4226}
4227
4228impl SseDecode for crate::model::PaymentState {
4229 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4231 let mut inner = <i32>::sse_decode(deserializer);
4232 return match inner {
4233 0 => crate::model::PaymentState::Created,
4234 1 => crate::model::PaymentState::Pending,
4235 2 => crate::model::PaymentState::Complete,
4236 3 => crate::model::PaymentState::Failed,
4237 4 => crate::model::PaymentState::TimedOut,
4238 5 => crate::model::PaymentState::Refundable,
4239 6 => crate::model::PaymentState::RefundPending,
4240 7 => crate::model::PaymentState::WaitingFeeAcceptance,
4241 _ => unreachable!("Invalid variant for PaymentState: {}", inner),
4242 };
4243 }
4244}
4245
4246impl SseDecode for crate::model::PaymentType {
4247 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4249 let mut inner = <i32>::sse_decode(deserializer);
4250 return match inner {
4251 0 => crate::model::PaymentType::Receive,
4252 1 => crate::model::PaymentType::Send,
4253 _ => unreachable!("Invalid variant for PaymentType: {}", inner),
4254 };
4255 }
4256}
4257
4258impl SseDecode for crate::model::PrepareBuyBitcoinRequest {
4259 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4261 let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4262 let mut var_amountSat = <u64>::sse_decode(deserializer);
4263 return crate::model::PrepareBuyBitcoinRequest {
4264 provider: var_provider,
4265 amount_sat: var_amountSat,
4266 };
4267 }
4268}
4269
4270impl SseDecode for crate::model::PrepareBuyBitcoinResponse {
4271 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4273 let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4274 let mut var_amountSat = <u64>::sse_decode(deserializer);
4275 let mut var_feesSat = <u64>::sse_decode(deserializer);
4276 return crate::model::PrepareBuyBitcoinResponse {
4277 provider: var_provider,
4278 amount_sat: var_amountSat,
4279 fees_sat: var_feesSat,
4280 };
4281 }
4282}
4283
4284impl SseDecode for crate::model::PrepareLnUrlPayRequest {
4285 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4287 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4288 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4289 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4290 let mut var_comment = <Option<String>>::sse_decode(deserializer);
4291 let mut var_validateSuccessActionUrl = <Option<bool>>::sse_decode(deserializer);
4292 return crate::model::PrepareLnUrlPayRequest {
4293 data: var_data,
4294 amount: var_amount,
4295 bip353_address: var_bip353Address,
4296 comment: var_comment,
4297 validate_success_action_url: var_validateSuccessActionUrl,
4298 };
4299 }
4300}
4301
4302impl SseDecode for crate::model::PrepareLnUrlPayResponse {
4303 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4305 let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4306 let mut var_feesSat = <u64>::sse_decode(deserializer);
4307 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4308 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4309 let mut var_comment = <Option<String>>::sse_decode(deserializer);
4310 let mut var_successAction =
4311 <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
4312 return crate::model::PrepareLnUrlPayResponse {
4313 destination: var_destination,
4314 fees_sat: var_feesSat,
4315 data: var_data,
4316 amount: var_amount,
4317 comment: var_comment,
4318 success_action: var_successAction,
4319 };
4320 }
4321}
4322
4323impl SseDecode for crate::model::PreparePayOnchainRequest {
4324 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4326 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4327 let mut var_feeRateSatPerVbyte = <Option<u32>>::sse_decode(deserializer);
4328 return crate::model::PreparePayOnchainRequest {
4329 amount: var_amount,
4330 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4331 };
4332 }
4333}
4334
4335impl SseDecode for crate::model::PreparePayOnchainResponse {
4336 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4338 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4339 let mut var_claimFeesSat = <u64>::sse_decode(deserializer);
4340 let mut var_totalFeesSat = <u64>::sse_decode(deserializer);
4341 return crate::model::PreparePayOnchainResponse {
4342 receiver_amount_sat: var_receiverAmountSat,
4343 claim_fees_sat: var_claimFeesSat,
4344 total_fees_sat: var_totalFeesSat,
4345 };
4346 }
4347}
4348
4349impl SseDecode for crate::model::PrepareReceiveRequest {
4350 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4352 let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4353 let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4354 return crate::model::PrepareReceiveRequest {
4355 payment_method: var_paymentMethod,
4356 amount: var_amount,
4357 };
4358 }
4359}
4360
4361impl SseDecode for crate::model::PrepareReceiveResponse {
4362 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4364 let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4365 let mut var_feesSat = <u64>::sse_decode(deserializer);
4366 let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4367 let mut var_minPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4368 let mut var_maxPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4369 let mut var_swapperFeerate = <Option<f64>>::sse_decode(deserializer);
4370 return crate::model::PrepareReceiveResponse {
4371 payment_method: var_paymentMethod,
4372 fees_sat: var_feesSat,
4373 amount: var_amount,
4374 min_payer_amount_sat: var_minPayerAmountSat,
4375 max_payer_amount_sat: var_maxPayerAmountSat,
4376 swapper_feerate: var_swapperFeerate,
4377 };
4378 }
4379}
4380
4381impl SseDecode for crate::model::PrepareRefundRequest {
4382 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4384 let mut var_swapAddress = <String>::sse_decode(deserializer);
4385 let mut var_refundAddress = <String>::sse_decode(deserializer);
4386 let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4387 return crate::model::PrepareRefundRequest {
4388 swap_address: var_swapAddress,
4389 refund_address: var_refundAddress,
4390 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4391 };
4392 }
4393}
4394
4395impl SseDecode for crate::model::PrepareRefundResponse {
4396 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4398 let mut var_txVsize = <u32>::sse_decode(deserializer);
4399 let mut var_txFeeSat = <u64>::sse_decode(deserializer);
4400 let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4401 return crate::model::PrepareRefundResponse {
4402 tx_vsize: var_txVsize,
4403 tx_fee_sat: var_txFeeSat,
4404 last_refund_tx_id: var_lastRefundTxId,
4405 };
4406 }
4407}
4408
4409impl SseDecode for crate::model::PrepareSendRequest {
4410 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4412 let mut var_destination = <String>::sse_decode(deserializer);
4413 let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4414 return crate::model::PrepareSendRequest {
4415 destination: var_destination,
4416 amount: var_amount,
4417 };
4418 }
4419}
4420
4421impl SseDecode for crate::model::PrepareSendResponse {
4422 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4424 let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4425 let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4426 let mut var_feesSat = <Option<u64>>::sse_decode(deserializer);
4427 let mut var_estimatedAssetFees = <Option<f64>>::sse_decode(deserializer);
4428 let mut var_exchangeAmountSat = <Option<u64>>::sse_decode(deserializer);
4429 return crate::model::PrepareSendResponse {
4430 destination: var_destination,
4431 amount: var_amount,
4432 fees_sat: var_feesSat,
4433 estimated_asset_fees: var_estimatedAssetFees,
4434 exchange_amount_sat: var_exchangeAmountSat,
4435 };
4436 }
4437}
4438
4439impl SseDecode for crate::bindings::Rate {
4440 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4442 let mut var_coin = <String>::sse_decode(deserializer);
4443 let mut var_value = <f64>::sse_decode(deserializer);
4444 return crate::bindings::Rate {
4445 coin: var_coin,
4446 value: var_value,
4447 };
4448 }
4449}
4450
4451impl SseDecode for crate::model::ReceiveAmount {
4452 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4454 let mut tag_ = <i32>::sse_decode(deserializer);
4455 match tag_ {
4456 0 => {
4457 let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
4458 return crate::model::ReceiveAmount::Bitcoin {
4459 payer_amount_sat: var_payerAmountSat,
4460 };
4461 }
4462 1 => {
4463 let mut var_assetId = <String>::sse_decode(deserializer);
4464 let mut var_payerAmount = <Option<f64>>::sse_decode(deserializer);
4465 return crate::model::ReceiveAmount::Asset {
4466 asset_id: var_assetId,
4467 payer_amount: var_payerAmount,
4468 };
4469 }
4470 _ => {
4471 unimplemented!("");
4472 }
4473 }
4474 }
4475}
4476
4477impl SseDecode for crate::model::ReceivePaymentRequest {
4478 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4480 let mut var_prepareResponse =
4481 <crate::model::PrepareReceiveResponse>::sse_decode(deserializer);
4482 let mut var_description = <Option<String>>::sse_decode(deserializer);
4483 let mut var_useDescriptionHash = <Option<bool>>::sse_decode(deserializer);
4484 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4485 return crate::model::ReceivePaymentRequest {
4486 prepare_response: var_prepareResponse,
4487 description: var_description,
4488 use_description_hash: var_useDescriptionHash,
4489 payer_note: var_payerNote,
4490 };
4491 }
4492}
4493
4494impl SseDecode for crate::model::ReceivePaymentResponse {
4495 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4497 let mut var_destination = <String>::sse_decode(deserializer);
4498 return crate::model::ReceivePaymentResponse {
4499 destination: var_destination,
4500 };
4501 }
4502}
4503
4504impl SseDecode for crate::model::RecommendedFees {
4505 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4507 let mut var_fastestFee = <u64>::sse_decode(deserializer);
4508 let mut var_halfHourFee = <u64>::sse_decode(deserializer);
4509 let mut var_hourFee = <u64>::sse_decode(deserializer);
4510 let mut var_economyFee = <u64>::sse_decode(deserializer);
4511 let mut var_minimumFee = <u64>::sse_decode(deserializer);
4512 return crate::model::RecommendedFees {
4513 fastest_fee: var_fastestFee,
4514 half_hour_fee: var_halfHourFee,
4515 hour_fee: var_hourFee,
4516 economy_fee: var_economyFee,
4517 minimum_fee: var_minimumFee,
4518 };
4519 }
4520}
4521
4522impl SseDecode for crate::model::RefundRequest {
4523 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4525 let mut var_swapAddress = <String>::sse_decode(deserializer);
4526 let mut var_refundAddress = <String>::sse_decode(deserializer);
4527 let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4528 return crate::model::RefundRequest {
4529 swap_address: var_swapAddress,
4530 refund_address: var_refundAddress,
4531 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4532 };
4533 }
4534}
4535
4536impl SseDecode for crate::model::RefundResponse {
4537 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4539 let mut var_refundTxId = <String>::sse_decode(deserializer);
4540 return crate::model::RefundResponse {
4541 refund_tx_id: var_refundTxId,
4542 };
4543 }
4544}
4545
4546impl SseDecode for crate::model::RefundableSwap {
4547 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4549 let mut var_swapAddress = <String>::sse_decode(deserializer);
4550 let mut var_timestamp = <u32>::sse_decode(deserializer);
4551 let mut var_amountSat = <u64>::sse_decode(deserializer);
4552 let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4553 return crate::model::RefundableSwap {
4554 swap_address: var_swapAddress,
4555 timestamp: var_timestamp,
4556 amount_sat: var_amountSat,
4557 last_refund_tx_id: var_lastRefundTxId,
4558 };
4559 }
4560}
4561
4562impl SseDecode for crate::model::RestoreRequest {
4563 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4565 let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
4566 return crate::model::RestoreRequest {
4567 backup_path: var_backupPath,
4568 };
4569 }
4570}
4571
4572impl SseDecode for crate::bindings::RouteHint {
4573 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4575 let mut var_hops = <Vec<crate::bindings::RouteHintHop>>::sse_decode(deserializer);
4576 return crate::bindings::RouteHint { hops: var_hops };
4577 }
4578}
4579
4580impl SseDecode for crate::bindings::RouteHintHop {
4581 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4583 let mut var_srcNodeId = <String>::sse_decode(deserializer);
4584 let mut var_shortChannelId = <String>::sse_decode(deserializer);
4585 let mut var_feesBaseMsat = <u32>::sse_decode(deserializer);
4586 let mut var_feesProportionalMillionths = <u32>::sse_decode(deserializer);
4587 let mut var_cltvExpiryDelta = <u64>::sse_decode(deserializer);
4588 let mut var_htlcMinimumMsat = <Option<u64>>::sse_decode(deserializer);
4589 let mut var_htlcMaximumMsat = <Option<u64>>::sse_decode(deserializer);
4590 return crate::bindings::RouteHintHop {
4591 src_node_id: var_srcNodeId,
4592 short_channel_id: var_shortChannelId,
4593 fees_base_msat: var_feesBaseMsat,
4594 fees_proportional_millionths: var_feesProportionalMillionths,
4595 cltv_expiry_delta: var_cltvExpiryDelta,
4596 htlc_minimum_msat: var_htlcMinimumMsat,
4597 htlc_maximum_msat: var_htlcMaximumMsat,
4598 };
4599 }
4600}
4601
4602impl SseDecode for crate::error::SdkError {
4603 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4605 let mut tag_ = <i32>::sse_decode(deserializer);
4606 match tag_ {
4607 0 => {
4608 return crate::error::SdkError::AlreadyStarted;
4609 }
4610 1 => {
4611 let mut var_err = <String>::sse_decode(deserializer);
4612 return crate::error::SdkError::Generic { err: var_err };
4613 }
4614 2 => {
4615 return crate::error::SdkError::NotStarted;
4616 }
4617 3 => {
4618 let mut var_err = <String>::sse_decode(deserializer);
4619 return crate::error::SdkError::ServiceConnectivity { err: var_err };
4620 }
4621 _ => {
4622 unimplemented!("");
4623 }
4624 }
4625 }
4626}
4627
4628impl SseDecode for crate::model::SdkEvent {
4629 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4631 let mut tag_ = <i32>::sse_decode(deserializer);
4632 match tag_ {
4633 0 => {
4634 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4635 return crate::model::SdkEvent::PaymentFailed {
4636 details: var_details,
4637 };
4638 }
4639 1 => {
4640 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4641 return crate::model::SdkEvent::PaymentPending {
4642 details: var_details,
4643 };
4644 }
4645 2 => {
4646 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4647 return crate::model::SdkEvent::PaymentRefundable {
4648 details: var_details,
4649 };
4650 }
4651 3 => {
4652 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4653 return crate::model::SdkEvent::PaymentRefunded {
4654 details: var_details,
4655 };
4656 }
4657 4 => {
4658 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4659 return crate::model::SdkEvent::PaymentRefundPending {
4660 details: var_details,
4661 };
4662 }
4663 5 => {
4664 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4665 return crate::model::SdkEvent::PaymentSucceeded {
4666 details: var_details,
4667 };
4668 }
4669 6 => {
4670 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4671 return crate::model::SdkEvent::PaymentWaitingConfirmation {
4672 details: var_details,
4673 };
4674 }
4675 7 => {
4676 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4677 return crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
4678 details: var_details,
4679 };
4680 }
4681 8 => {
4682 return crate::model::SdkEvent::Synced;
4683 }
4684 9 => {
4685 let mut var_didPullNewRecords = <bool>::sse_decode(deserializer);
4686 return crate::model::SdkEvent::DataSynced {
4687 did_pull_new_records: var_didPullNewRecords,
4688 };
4689 }
4690 _ => {
4691 unimplemented!("");
4692 }
4693 }
4694 }
4695}
4696
4697impl SseDecode for crate::model::SendDestination {
4698 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4700 let mut tag_ = <i32>::sse_decode(deserializer);
4701 match tag_ {
4702 0 => {
4703 let mut var_addressData =
4704 <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
4705 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4706 return crate::model::SendDestination::LiquidAddress {
4707 address_data: var_addressData,
4708 bip353_address: var_bip353Address,
4709 };
4710 }
4711 1 => {
4712 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
4713 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4714 return crate::model::SendDestination::Bolt11 {
4715 invoice: var_invoice,
4716 bip353_address: var_bip353Address,
4717 };
4718 }
4719 2 => {
4720 let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
4721 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4722 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4723 return crate::model::SendDestination::Bolt12 {
4724 offer: var_offer,
4725 receiver_amount_sat: var_receiverAmountSat,
4726 bip353_address: var_bip353Address,
4727 };
4728 }
4729 _ => {
4730 unimplemented!("");
4731 }
4732 }
4733 }
4734}
4735
4736impl SseDecode for crate::model::SendPaymentRequest {
4737 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4739 let mut var_prepareResponse = <crate::model::PrepareSendResponse>::sse_decode(deserializer);
4740 let mut var_useAssetFees = <Option<bool>>::sse_decode(deserializer);
4741 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4742 return crate::model::SendPaymentRequest {
4743 prepare_response: var_prepareResponse,
4744 use_asset_fees: var_useAssetFees,
4745 payer_note: var_payerNote,
4746 };
4747 }
4748}
4749
4750impl SseDecode for crate::model::SendPaymentResponse {
4751 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4753 let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
4754 return crate::model::SendPaymentResponse {
4755 payment: var_payment,
4756 };
4757 }
4758}
4759
4760impl SseDecode for crate::model::SignMessageRequest {
4761 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4763 let mut var_message = <String>::sse_decode(deserializer);
4764 return crate::model::SignMessageRequest {
4765 message: var_message,
4766 };
4767 }
4768}
4769
4770impl SseDecode for crate::model::SignMessageResponse {
4771 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4773 let mut var_signature = <String>::sse_decode(deserializer);
4774 return crate::model::SignMessageResponse {
4775 signature: var_signature,
4776 };
4777 }
4778}
4779
4780impl SseDecode for crate::bindings::SuccessAction {
4781 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4783 let mut tag_ = <i32>::sse_decode(deserializer);
4784 match tag_ {
4785 0 => {
4786 let mut var_data =
4787 <crate::bindings::AesSuccessActionData>::sse_decode(deserializer);
4788 return crate::bindings::SuccessAction::Aes { data: var_data };
4789 }
4790 1 => {
4791 let mut var_data =
4792 <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4793 return crate::bindings::SuccessAction::Message { data: var_data };
4794 }
4795 2 => {
4796 let mut var_data =
4797 <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4798 return crate::bindings::SuccessAction::Url { data: var_data };
4799 }
4800 _ => {
4801 unimplemented!("");
4802 }
4803 }
4804 }
4805}
4806
4807impl SseDecode for crate::bindings::SuccessActionProcessed {
4808 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4810 let mut tag_ = <i32>::sse_decode(deserializer);
4811 match tag_ {
4812 0 => {
4813 let mut var_result =
4814 <crate::bindings::AesSuccessActionDataResult>::sse_decode(deserializer);
4815 return crate::bindings::SuccessActionProcessed::Aes { result: var_result };
4816 }
4817 1 => {
4818 let mut var_data =
4819 <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4820 return crate::bindings::SuccessActionProcessed::Message { data: var_data };
4821 }
4822 2 => {
4823 let mut var_data =
4824 <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4825 return crate::bindings::SuccessActionProcessed::Url { data: var_data };
4826 }
4827 _ => {
4828 unimplemented!("");
4829 }
4830 }
4831 }
4832}
4833
4834impl SseDecode for crate::bindings::Symbol {
4835 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4837 let mut var_grapheme = <Option<String>>::sse_decode(deserializer);
4838 let mut var_template = <Option<String>>::sse_decode(deserializer);
4839 let mut var_rtl = <Option<bool>>::sse_decode(deserializer);
4840 let mut var_position = <Option<u32>>::sse_decode(deserializer);
4841 return crate::bindings::Symbol {
4842 grapheme: var_grapheme,
4843 template: var_template,
4844 rtl: var_rtl,
4845 position: var_position,
4846 };
4847 }
4848}
4849
4850impl SseDecode for u16 {
4851 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4853 deserializer.cursor.read_u16::<NativeEndian>().unwrap()
4854 }
4855}
4856
4857impl SseDecode for u32 {
4858 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4860 deserializer.cursor.read_u32::<NativeEndian>().unwrap()
4861 }
4862}
4863
4864impl SseDecode for u64 {
4865 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4867 deserializer.cursor.read_u64::<NativeEndian>().unwrap()
4868 }
4869}
4870
4871impl SseDecode for u8 {
4872 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4874 deserializer.cursor.read_u8().unwrap()
4875 }
4876}
4877
4878impl SseDecode for () {
4879 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
4881}
4882
4883impl SseDecode for crate::bindings::UrlSuccessActionData {
4884 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4886 let mut var_description = <String>::sse_decode(deserializer);
4887 let mut var_url = <String>::sse_decode(deserializer);
4888 let mut var_matchesCallbackDomain = <bool>::sse_decode(deserializer);
4889 return crate::bindings::UrlSuccessActionData {
4890 description: var_description,
4891 url: var_url,
4892 matches_callback_domain: var_matchesCallbackDomain,
4893 };
4894 }
4895}
4896
4897impl SseDecode for usize {
4898 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4900 deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
4901 }
4902}
4903
4904impl SseDecode for crate::model::WalletInfo {
4905 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4907 let mut var_balanceSat = <u64>::sse_decode(deserializer);
4908 let mut var_pendingSendSat = <u64>::sse_decode(deserializer);
4909 let mut var_pendingReceiveSat = <u64>::sse_decode(deserializer);
4910 let mut var_fingerprint = <String>::sse_decode(deserializer);
4911 let mut var_pubkey = <String>::sse_decode(deserializer);
4912 let mut var_assetBalances = <Vec<crate::model::AssetBalance>>::sse_decode(deserializer);
4913 return crate::model::WalletInfo {
4914 balance_sat: var_balanceSat,
4915 pending_send_sat: var_pendingSendSat,
4916 pending_receive_sat: var_pendingReceiveSat,
4917 fingerprint: var_fingerprint,
4918 pubkey: var_pubkey,
4919 asset_balances: var_assetBalances,
4920 };
4921 }
4922}
4923
4924fn pde_ffi_dispatcher_primary_impl(
4925 func_id: i32,
4926 port: flutter_rust_bridge::for_generated::MessagePort,
4927 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4928 rust_vec_len: i32,
4929 data_len: i32,
4930) {
4931 match func_id {
4933 _ => unreachable!(),
4934 }
4935}
4936
4937fn pde_ffi_dispatcher_sync_impl(
4938 func_id: i32,
4939 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4940 rust_vec_len: i32,
4941 data_len: i32,
4942) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
4943 match func_id {
4945 _ => unreachable!(),
4946 }
4947}
4948
4949impl flutter_rust_bridge::IntoDart for FrbWrapper<BindingLiquidSdk> {
4953 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4954 flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0)
4955 .into_dart()
4956 }
4957}
4958impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<BindingLiquidSdk> {}
4959
4960impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<BindingLiquidSdk>> for BindingLiquidSdk {
4961 fn into_into_dart(self) -> FrbWrapper<BindingLiquidSdk> {
4962 self.into()
4963 }
4964}
4965
4966impl flutter_rust_bridge::IntoDart for crate::model::AcceptPaymentProposedFeesRequest {
4968 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4969 [self.response.into_into_dart().into_dart()].into_dart()
4970 }
4971}
4972impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4973 for crate::model::AcceptPaymentProposedFeesRequest
4974{
4975}
4976impl flutter_rust_bridge::IntoIntoDart<crate::model::AcceptPaymentProposedFeesRequest>
4977 for crate::model::AcceptPaymentProposedFeesRequest
4978{
4979 fn into_into_dart(self) -> crate::model::AcceptPaymentProposedFeesRequest {
4980 self
4981 }
4982}
4983impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionData> {
4985 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4986 [
4987 self.0.description.into_into_dart().into_dart(),
4988 self.0.ciphertext.into_into_dart().into_dart(),
4989 self.0.iv.into_into_dart().into_dart(),
4990 ]
4991 .into_dart()
4992 }
4993}
4994impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4995 for FrbWrapper<crate::bindings::AesSuccessActionData>
4996{
4997}
4998impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionData>>
4999 for crate::bindings::AesSuccessActionData
5000{
5001 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionData> {
5002 self.into()
5003 }
5004}
5005impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5007 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5008 [
5009 self.0.description.into_into_dart().into_dart(),
5010 self.0.plaintext.into_into_dart().into_dart(),
5011 ]
5012 .into_dart()
5013 }
5014}
5015impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5016 for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>
5017{
5018}
5019impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>>
5020 for crate::bindings::AesSuccessActionDataDecrypted
5021{
5022 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5023 self.into()
5024 }
5025}
5026impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5028 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5029 match self.0 {
5030 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
5031 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
5032 }
5033 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
5034 [1.into_dart(), reason.into_into_dart().into_dart()].into_dart()
5035 }
5036 _ => {
5037 unimplemented!("");
5038 }
5039 }
5040 }
5041}
5042impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5043 for FrbWrapper<crate::bindings::AesSuccessActionDataResult>
5044{
5045}
5046impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataResult>>
5047 for crate::bindings::AesSuccessActionDataResult
5048{
5049 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5050 self.into()
5051 }
5052}
5053impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Amount> {
5055 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5056 match self.0 {
5057 crate::bindings::Amount::Bitcoin { amount_msat } => {
5058 [0.into_dart(), amount_msat.into_into_dart().into_dart()].into_dart()
5059 }
5060 crate::bindings::Amount::Currency {
5061 iso4217_code,
5062 fractional_amount,
5063 } => [
5064 1.into_dart(),
5065 iso4217_code.into_into_dart().into_dart(),
5066 fractional_amount.into_into_dart().into_dart(),
5067 ]
5068 .into_dart(),
5069 _ => {
5070 unimplemented!("");
5071 }
5072 }
5073 }
5074}
5075impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5076 for FrbWrapper<crate::bindings::Amount>
5077{
5078}
5079impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Amount>>
5080 for crate::bindings::Amount
5081{
5082 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Amount> {
5083 self.into()
5084 }
5085}
5086impl flutter_rust_bridge::IntoDart for crate::model::AssetBalance {
5088 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5089 [
5090 self.asset_id.into_into_dart().into_dart(),
5091 self.balance_sat.into_into_dart().into_dart(),
5092 self.name.into_into_dart().into_dart(),
5093 self.ticker.into_into_dart().into_dart(),
5094 self.balance.into_into_dart().into_dart(),
5095 ]
5096 .into_dart()
5097 }
5098}
5099impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetBalance {}
5100impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetBalance> for crate::model::AssetBalance {
5101 fn into_into_dart(self) -> crate::model::AssetBalance {
5102 self
5103 }
5104}
5105impl flutter_rust_bridge::IntoDart for crate::model::AssetInfo {
5107 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5108 [
5109 self.name.into_into_dart().into_dart(),
5110 self.ticker.into_into_dart().into_dart(),
5111 self.amount.into_into_dart().into_dart(),
5112 self.fees.into_into_dart().into_dart(),
5113 ]
5114 .into_dart()
5115 }
5116}
5117impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetInfo {}
5118impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetInfo> for crate::model::AssetInfo {
5119 fn into_into_dart(self) -> crate::model::AssetInfo {
5120 self
5121 }
5122}
5123impl flutter_rust_bridge::IntoDart for crate::model::AssetMetadata {
5125 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5126 [
5127 self.asset_id.into_into_dart().into_dart(),
5128 self.name.into_into_dart().into_dart(),
5129 self.ticker.into_into_dart().into_dart(),
5130 self.precision.into_into_dart().into_dart(),
5131 self.fiat_id.into_into_dart().into_dart(),
5132 ]
5133 .into_dart()
5134 }
5135}
5136impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetMetadata {}
5137impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetMetadata>
5138 for crate::model::AssetMetadata
5139{
5140 fn into_into_dart(self) -> crate::model::AssetMetadata {
5141 self
5142 }
5143}
5144impl flutter_rust_bridge::IntoDart for crate::model::BackupRequest {
5146 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5147 [self.backup_path.into_into_dart().into_dart()].into_dart()
5148 }
5149}
5150impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BackupRequest {}
5151impl flutter_rust_bridge::IntoIntoDart<crate::model::BackupRequest>
5152 for crate::model::BackupRequest
5153{
5154 fn into_into_dart(self) -> crate::model::BackupRequest {
5155 self
5156 }
5157}
5158impl flutter_rust_bridge::IntoDart for crate::bindings::BindingEventListener {
5160 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5161 [self.stream.into_into_dart().into_dart()].into_dart()
5162 }
5163}
5164impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5165 for crate::bindings::BindingEventListener
5166{
5167}
5168impl flutter_rust_bridge::IntoIntoDart<crate::bindings::BindingEventListener>
5169 for crate::bindings::BindingEventListener
5170{
5171 fn into_into_dart(self) -> crate::bindings::BindingEventListener {
5172 self
5173 }
5174}
5175impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::BitcoinAddressData> {
5177 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5178 [
5179 self.0.address.into_into_dart().into_dart(),
5180 self.0.network.into_into_dart().into_dart(),
5181 self.0.amount_sat.into_into_dart().into_dart(),
5182 self.0.label.into_into_dart().into_dart(),
5183 self.0.message.into_into_dart().into_dart(),
5184 ]
5185 .into_dart()
5186 }
5187}
5188impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5189 for FrbWrapper<crate::bindings::BitcoinAddressData>
5190{
5191}
5192impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::BitcoinAddressData>>
5193 for crate::bindings::BitcoinAddressData
5194{
5195 fn into_into_dart(self) -> FrbWrapper<crate::bindings::BitcoinAddressData> {
5196 self.into()
5197 }
5198}
5199impl flutter_rust_bridge::IntoDart for crate::model::BlockchainExplorer {
5201 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5202 match self {
5203 crate::model::BlockchainExplorer::Electrum { url } => {
5204 [0.into_dart(), url.into_into_dart().into_dart()].into_dart()
5205 }
5206 crate::model::BlockchainExplorer::Esplora {
5207 url,
5208 use_waterfalls,
5209 } => [
5210 1.into_dart(),
5211 url.into_into_dart().into_dart(),
5212 use_waterfalls.into_into_dart().into_dart(),
5213 ]
5214 .into_dart(),
5215 _ => {
5216 unimplemented!("");
5217 }
5218 }
5219 }
5220}
5221impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5222 for crate::model::BlockchainExplorer
5223{
5224}
5225impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainExplorer>
5226 for crate::model::BlockchainExplorer
5227{
5228 fn into_into_dart(self) -> crate::model::BlockchainExplorer {
5229 self
5230 }
5231}
5232impl flutter_rust_bridge::IntoDart for crate::model::BlockchainInfo {
5234 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5235 [
5236 self.liquid_tip.into_into_dart().into_dart(),
5237 self.bitcoin_tip.into_into_dart().into_dart(),
5238 ]
5239 .into_dart()
5240 }
5241}
5242impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BlockchainInfo {}
5243impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainInfo>
5244 for crate::model::BlockchainInfo
5245{
5246 fn into_into_dart(self) -> crate::model::BlockchainInfo {
5247 self
5248 }
5249}
5250impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinProvider {
5252 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5253 match self {
5254 Self::Moonpay => 0.into_dart(),
5255 _ => unreachable!(),
5256 }
5257 }
5258}
5259impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5260 for crate::model::BuyBitcoinProvider
5261{
5262}
5263impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinProvider>
5264 for crate::model::BuyBitcoinProvider
5265{
5266 fn into_into_dart(self) -> crate::model::BuyBitcoinProvider {
5267 self
5268 }
5269}
5270impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinRequest {
5272 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5273 [
5274 self.prepare_response.into_into_dart().into_dart(),
5275 self.redirect_url.into_into_dart().into_dart(),
5276 ]
5277 .into_dart()
5278 }
5279}
5280impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5281 for crate::model::BuyBitcoinRequest
5282{
5283}
5284impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinRequest>
5285 for crate::model::BuyBitcoinRequest
5286{
5287 fn into_into_dart(self) -> crate::model::BuyBitcoinRequest {
5288 self
5289 }
5290}
5291impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageRequest {
5293 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5294 [
5295 self.message.into_into_dart().into_dart(),
5296 self.pubkey.into_into_dart().into_dart(),
5297 self.signature.into_into_dart().into_dart(),
5298 ]
5299 .into_dart()
5300 }
5301}
5302impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5303 for crate::model::CheckMessageRequest
5304{
5305}
5306impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageRequest>
5307 for crate::model::CheckMessageRequest
5308{
5309 fn into_into_dart(self) -> crate::model::CheckMessageRequest {
5310 self
5311 }
5312}
5313impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageResponse {
5315 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5316 [self.is_valid.into_into_dart().into_dart()].into_dart()
5317 }
5318}
5319impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5320 for crate::model::CheckMessageResponse
5321{
5322}
5323impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageResponse>
5324 for crate::model::CheckMessageResponse
5325{
5326 fn into_into_dart(self) -> crate::model::CheckMessageResponse {
5327 self
5328 }
5329}
5330impl flutter_rust_bridge::IntoDart for crate::model::Config {
5332 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5333 [
5334 self.liquid_explorer.into_into_dart().into_dart(),
5335 self.bitcoin_explorer.into_into_dart().into_dart(),
5336 self.working_dir.into_into_dart().into_dart(),
5337 self.network.into_into_dart().into_dart(),
5338 self.payment_timeout_sec.into_into_dart().into_dart(),
5339 self.sync_service_url.into_into_dart().into_dart(),
5340 self.zero_conf_max_amount_sat.into_into_dart().into_dart(),
5341 self.breez_api_key.into_into_dart().into_dart(),
5342 self.external_input_parsers.into_into_dart().into_dart(),
5343 self.use_default_external_input_parsers
5344 .into_into_dart()
5345 .into_dart(),
5346 self.onchain_fee_rate_leeway_sat
5347 .into_into_dart()
5348 .into_dart(),
5349 self.asset_metadata.into_into_dart().into_dart(),
5350 self.sideswap_api_key.into_into_dart().into_dart(),
5351 self.use_magic_routing_hints.into_into_dart().into_dart(),
5352 ]
5353 .into_dart()
5354 }
5355}
5356impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Config {}
5357impl flutter_rust_bridge::IntoIntoDart<crate::model::Config> for crate::model::Config {
5358 fn into_into_dart(self) -> crate::model::Config {
5359 self
5360 }
5361}
5362impl flutter_rust_bridge::IntoDart for crate::model::ConnectRequest {
5364 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5365 [
5366 self.config.into_into_dart().into_dart(),
5367 self.mnemonic.into_into_dart().into_dart(),
5368 self.passphrase.into_into_dart().into_dart(),
5369 self.seed.into_into_dart().into_dart(),
5370 ]
5371 .into_dart()
5372 }
5373}
5374impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ConnectRequest {}
5375impl flutter_rust_bridge::IntoIntoDart<crate::model::ConnectRequest>
5376 for crate::model::ConnectRequest
5377{
5378 fn into_into_dart(self) -> crate::model::ConnectRequest {
5379 self
5380 }
5381}
5382impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceRequest {
5384 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5385 [
5386 self.offer.into_into_dart().into_dart(),
5387 self.invoice_request.into_into_dart().into_dart(),
5388 ]
5389 .into_dart()
5390 }
5391}
5392impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5393 for crate::model::CreateBolt12InvoiceRequest
5394{
5395}
5396impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceRequest>
5397 for crate::model::CreateBolt12InvoiceRequest
5398{
5399 fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceRequest {
5400 self
5401 }
5402}
5403impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceResponse {
5405 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5406 [self.invoice.into_into_dart().into_dart()].into_dart()
5407 }
5408}
5409impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5410 for crate::model::CreateBolt12InvoiceResponse
5411{
5412}
5413impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceResponse>
5414 for crate::model::CreateBolt12InvoiceResponse
5415{
5416 fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceResponse {
5417 self
5418 }
5419}
5420impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::CurrencyInfo> {
5422 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5423 [
5424 self.0.name.into_into_dart().into_dart(),
5425 self.0.fraction_size.into_into_dart().into_dart(),
5426 self.0.spacing.into_into_dart().into_dart(),
5427 self.0.symbol.into_into_dart().into_dart(),
5428 self.0.uniq_symbol.into_into_dart().into_dart(),
5429 self.0.localized_name.into_into_dart().into_dart(),
5430 self.0.locale_overrides.into_into_dart().into_dart(),
5431 ]
5432 .into_dart()
5433 }
5434}
5435impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5436 for FrbWrapper<crate::bindings::CurrencyInfo>
5437{
5438}
5439impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::CurrencyInfo>>
5440 for crate::bindings::CurrencyInfo
5441{
5442 fn into_into_dart(self) -> FrbWrapper<crate::bindings::CurrencyInfo> {
5443 self.into()
5444 }
5445}
5446impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::ExternalInputParser> {
5448 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5449 [
5450 self.0.provider_id.into_into_dart().into_dart(),
5451 self.0.input_regex.into_into_dart().into_dart(),
5452 self.0.parser_url.into_into_dart().into_dart(),
5453 ]
5454 .into_dart()
5455 }
5456}
5457impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5458 for FrbWrapper<crate::bindings::ExternalInputParser>
5459{
5460}
5461impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::ExternalInputParser>>
5462 for crate::bindings::ExternalInputParser
5463{
5464 fn into_into_dart(self) -> FrbWrapper<crate::bindings::ExternalInputParser> {
5465 self.into()
5466 }
5467}
5468impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesRequest {
5470 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5471 [self.swap_id.into_into_dart().into_dart()].into_dart()
5472 }
5473}
5474impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5475 for crate::model::FetchPaymentProposedFeesRequest
5476{
5477}
5478impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesRequest>
5479 for crate::model::FetchPaymentProposedFeesRequest
5480{
5481 fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesRequest {
5482 self
5483 }
5484}
5485impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesResponse {
5487 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5488 [
5489 self.swap_id.into_into_dart().into_dart(),
5490 self.fees_sat.into_into_dart().into_dart(),
5491 self.payer_amount_sat.into_into_dart().into_dart(),
5492 self.receiver_amount_sat.into_into_dart().into_dart(),
5493 ]
5494 .into_dart()
5495 }
5496}
5497impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5498 for crate::model::FetchPaymentProposedFeesResponse
5499{
5500}
5501impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesResponse>
5502 for crate::model::FetchPaymentProposedFeesResponse
5503{
5504 fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesResponse {
5505 self
5506 }
5507}
5508impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::FiatCurrency> {
5510 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5511 [
5512 self.0.id.into_into_dart().into_dart(),
5513 self.0.info.into_into_dart().into_dart(),
5514 ]
5515 .into_dart()
5516 }
5517}
5518impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5519 for FrbWrapper<crate::bindings::FiatCurrency>
5520{
5521}
5522impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::FiatCurrency>>
5523 for crate::bindings::FiatCurrency
5524{
5525 fn into_into_dart(self) -> FrbWrapper<crate::bindings::FiatCurrency> {
5526 self.into()
5527 }
5528}
5529impl flutter_rust_bridge::IntoDart for crate::model::GetInfoResponse {
5531 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5532 [
5533 self.wallet_info.into_into_dart().into_dart(),
5534 self.blockchain_info.into_into_dart().into_dart(),
5535 ]
5536 .into_dart()
5537 }
5538}
5539impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::GetInfoResponse {}
5540impl flutter_rust_bridge::IntoIntoDart<crate::model::GetInfoResponse>
5541 for crate::model::GetInfoResponse
5542{
5543 fn into_into_dart(self) -> crate::model::GetInfoResponse {
5544 self
5545 }
5546}
5547impl flutter_rust_bridge::IntoDart for crate::model::GetPaymentRequest {
5549 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5550 match self {
5551 crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
5552 [0.into_dart(), payment_hash.into_into_dart().into_dart()].into_dart()
5553 }
5554 crate::model::GetPaymentRequest::SwapId { swap_id } => {
5555 [1.into_dart(), swap_id.into_into_dart().into_dart()].into_dart()
5556 }
5557 _ => {
5558 unimplemented!("");
5559 }
5560 }
5561 }
5562}
5563impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5564 for crate::model::GetPaymentRequest
5565{
5566}
5567impl flutter_rust_bridge::IntoIntoDart<crate::model::GetPaymentRequest>
5568 for crate::model::GetPaymentRequest
5569{
5570 fn into_into_dart(self) -> crate::model::GetPaymentRequest {
5571 self
5572 }
5573}
5574impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::InputType> {
5576 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5577 match self.0 {
5578 crate::bindings::InputType::BitcoinAddress { address } => {
5579 [0.into_dart(), address.into_into_dart().into_dart()].into_dart()
5580 }
5581 crate::bindings::InputType::LiquidAddress { address } => {
5582 [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5583 }
5584 crate::bindings::InputType::Bolt11 { invoice } => {
5585 [2.into_dart(), invoice.into_into_dart().into_dart()].into_dart()
5586 }
5587 crate::bindings::InputType::Bolt12Offer {
5588 offer,
5589 bip353_address,
5590 } => [
5591 3.into_dart(),
5592 offer.into_into_dart().into_dart(),
5593 bip353_address.into_into_dart().into_dart(),
5594 ]
5595 .into_dart(),
5596 crate::bindings::InputType::NodeId { node_id } => {
5597 [4.into_dart(), node_id.into_into_dart().into_dart()].into_dart()
5598 }
5599 crate::bindings::InputType::Url { url } => {
5600 [5.into_dart(), url.into_into_dart().into_dart()].into_dart()
5601 }
5602 crate::bindings::InputType::LnUrlPay {
5603 data,
5604 bip353_address,
5605 } => [
5606 6.into_dart(),
5607 data.into_into_dart().into_dart(),
5608 bip353_address.into_into_dart().into_dart(),
5609 ]
5610 .into_dart(),
5611 crate::bindings::InputType::LnUrlWithdraw { data } => {
5612 [7.into_dart(), data.into_into_dart().into_dart()].into_dart()
5613 }
5614 crate::bindings::InputType::LnUrlAuth { data } => {
5615 [8.into_dart(), data.into_into_dart().into_dart()].into_dart()
5616 }
5617 crate::bindings::InputType::LnUrlError { data } => {
5618 [9.into_dart(), data.into_into_dart().into_dart()].into_dart()
5619 }
5620 _ => {
5621 unimplemented!("");
5622 }
5623 }
5624 }
5625}
5626impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5627 for FrbWrapper<crate::bindings::InputType>
5628{
5629}
5630impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::InputType>>
5631 for crate::bindings::InputType
5632{
5633 fn into_into_dart(self) -> FrbWrapper<crate::bindings::InputType> {
5634 self.into()
5635 }
5636}
5637impl flutter_rust_bridge::IntoDart for crate::model::LightningPaymentLimitsResponse {
5639 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5640 [
5641 self.send.into_into_dart().into_dart(),
5642 self.receive.into_into_dart().into_dart(),
5643 ]
5644 .into_dart()
5645 }
5646}
5647impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5648 for crate::model::LightningPaymentLimitsResponse
5649{
5650}
5651impl flutter_rust_bridge::IntoIntoDart<crate::model::LightningPaymentLimitsResponse>
5652 for crate::model::LightningPaymentLimitsResponse
5653{
5654 fn into_into_dart(self) -> crate::model::LightningPaymentLimitsResponse {
5655 self
5656 }
5657}
5658impl flutter_rust_bridge::IntoDart for crate::model::Limits {
5660 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5661 [
5662 self.min_sat.into_into_dart().into_dart(),
5663 self.max_sat.into_into_dart().into_dart(),
5664 self.max_zero_conf_sat.into_into_dart().into_dart(),
5665 ]
5666 .into_dart()
5667 }
5668}
5669impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Limits {}
5670impl flutter_rust_bridge::IntoIntoDart<crate::model::Limits> for crate::model::Limits {
5671 fn into_into_dart(self) -> crate::model::Limits {
5672 self
5673 }
5674}
5675impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LiquidAddressData> {
5677 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5678 [
5679 self.0.address.into_into_dart().into_dart(),
5680 self.0.network.into_into_dart().into_dart(),
5681 self.0.asset_id.into_into_dart().into_dart(),
5682 self.0.amount.into_into_dart().into_dart(),
5683 self.0.amount_sat.into_into_dart().into_dart(),
5684 self.0.label.into_into_dart().into_dart(),
5685 self.0.message.into_into_dart().into_dart(),
5686 ]
5687 .into_dart()
5688 }
5689}
5690impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5691 for FrbWrapper<crate::bindings::LiquidAddressData>
5692{
5693}
5694impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LiquidAddressData>>
5695 for crate::bindings::LiquidAddressData
5696{
5697 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LiquidAddressData> {
5698 self.into()
5699 }
5700}
5701impl flutter_rust_bridge::IntoDart for crate::model::LiquidNetwork {
5703 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5704 match self {
5705 Self::Mainnet => 0.into_dart(),
5706 Self::Testnet => 1.into_dart(),
5707 Self::Regtest => 2.into_dart(),
5708 _ => unreachable!(),
5709 }
5710 }
5711}
5712impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LiquidNetwork {}
5713impl flutter_rust_bridge::IntoIntoDart<crate::model::LiquidNetwork>
5714 for crate::model::LiquidNetwork
5715{
5716 fn into_into_dart(self) -> crate::model::LiquidNetwork {
5717 self
5718 }
5719}
5720impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentDetails {
5722 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5723 match self {
5724 crate::model::ListPaymentDetails::Liquid {
5725 asset_id,
5726 destination,
5727 } => [
5728 0.into_dart(),
5729 asset_id.into_into_dart().into_dart(),
5730 destination.into_into_dart().into_dart(),
5731 ]
5732 .into_dart(),
5733 crate::model::ListPaymentDetails::Bitcoin { address } => {
5734 [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5735 }
5736 _ => {
5737 unimplemented!("");
5738 }
5739 }
5740 }
5741}
5742impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5743 for crate::model::ListPaymentDetails
5744{
5745}
5746impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentDetails>
5747 for crate::model::ListPaymentDetails
5748{
5749 fn into_into_dart(self) -> crate::model::ListPaymentDetails {
5750 self
5751 }
5752}
5753impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentsRequest {
5755 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5756 [
5757 self.filters.into_into_dart().into_dart(),
5758 self.states.into_into_dart().into_dart(),
5759 self.from_timestamp.into_into_dart().into_dart(),
5760 self.to_timestamp.into_into_dart().into_dart(),
5761 self.offset.into_into_dart().into_dart(),
5762 self.limit.into_into_dart().into_dart(),
5763 self.details.into_into_dart().into_dart(),
5764 self.sort_ascending.into_into_dart().into_dart(),
5765 ]
5766 .into_dart()
5767 }
5768}
5769impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5770 for crate::model::ListPaymentsRequest
5771{
5772}
5773impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentsRequest>
5774 for crate::model::ListPaymentsRequest
5775{
5776 fn into_into_dart(self) -> crate::model::ListPaymentsRequest {
5777 self
5778 }
5779}
5780impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNInvoice> {
5782 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5783 [
5784 self.0.bolt11.into_into_dart().into_dart(),
5785 self.0.network.into_into_dart().into_dart(),
5786 self.0.payee_pubkey.into_into_dart().into_dart(),
5787 self.0.payment_hash.into_into_dart().into_dart(),
5788 self.0.description.into_into_dart().into_dart(),
5789 self.0.description_hash.into_into_dart().into_dart(),
5790 self.0.amount_msat.into_into_dart().into_dart(),
5791 self.0.timestamp.into_into_dart().into_dart(),
5792 self.0.expiry.into_into_dart().into_dart(),
5793 self.0.routing_hints.into_into_dart().into_dart(),
5794 self.0.payment_secret.into_into_dart().into_dart(),
5795 self.0
5796 .min_final_cltv_expiry_delta
5797 .into_into_dart()
5798 .into_dart(),
5799 ]
5800 .into_dart()
5801 }
5802}
5803impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5804 for FrbWrapper<crate::bindings::LNInvoice>
5805{
5806}
5807impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNInvoice>>
5808 for crate::bindings::LNInvoice
5809{
5810 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNInvoice> {
5811 self.into()
5812 }
5813}
5814impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNOffer> {
5816 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5817 [
5818 self.0.offer.into_into_dart().into_dart(),
5819 self.0.chains.into_into_dart().into_dart(),
5820 self.0.min_amount.into_into_dart().into_dart(),
5821 self.0.description.into_into_dart().into_dart(),
5822 self.0.absolute_expiry.into_into_dart().into_dart(),
5823 self.0.issuer.into_into_dart().into_dart(),
5824 self.0.signing_pubkey.into_into_dart().into_dart(),
5825 self.0.paths.into_into_dart().into_dart(),
5826 ]
5827 .into_dart()
5828 }
5829}
5830impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5831 for FrbWrapper<crate::bindings::LNOffer>
5832{
5833}
5834impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNOffer>>
5835 for crate::bindings::LNOffer
5836{
5837 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNOffer> {
5838 self.into()
5839 }
5840}
5841impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5843 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5844 [self.0.blinded_hops.into_into_dart().into_dart()].into_dart()
5845 }
5846}
5847impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5848 for FrbWrapper<crate::bindings::LnOfferBlindedPath>
5849{
5850}
5851impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnOfferBlindedPath>>
5852 for crate::bindings::LnOfferBlindedPath
5853{
5854 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5855 self.into()
5856 }
5857}
5858impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlAuthError {
5860 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5861 match self {
5862 crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
5863 [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
5864 }
5865 crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
5866 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5867 }
5868 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
5869 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5870 }
5871 _ => {
5872 unimplemented!("");
5873 }
5874 }
5875 }
5876}
5877impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5878 for crate::bindings::duplicates::LnUrlAuthError
5879{
5880}
5881impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlAuthError>
5882 for crate::bindings::duplicates::LnUrlAuthError
5883{
5884 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlAuthError {
5885 self
5886 }
5887}
5888impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5890 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5891 [
5892 self.0.k1.into_into_dart().into_dart(),
5893 self.0.action.into_into_dart().into_dart(),
5894 self.0.domain.into_into_dart().into_dart(),
5895 self.0.url.into_into_dart().into_dart(),
5896 ]
5897 .into_dart()
5898 }
5899}
5900impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5901 for FrbWrapper<crate::bindings::LnUrlAuthRequestData>
5902{
5903}
5904impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlAuthRequestData>>
5905 for crate::bindings::LnUrlAuthRequestData
5906{
5907 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5908 self.into()
5909 }
5910}
5911impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlCallbackStatus {
5913 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5914 match self {
5915 crate::bindings::duplicates::LnUrlCallbackStatus::Ok => [0.into_dart()].into_dart(),
5916 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
5917 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
5918 }
5919 _ => {
5920 unimplemented!("");
5921 }
5922 }
5923 }
5924}
5925impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5926 for crate::bindings::duplicates::LnUrlCallbackStatus
5927{
5928}
5929impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlCallbackStatus>
5930 for crate::bindings::duplicates::LnUrlCallbackStatus
5931{
5932 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
5933 self
5934 }
5935}
5936impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlErrorData> {
5938 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5939 [self.0.reason.into_into_dart().into_dart()].into_dart()
5940 }
5941}
5942impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5943 for FrbWrapper<crate::bindings::LnUrlErrorData>
5944{
5945}
5946impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlErrorData>>
5947 for crate::bindings::LnUrlErrorData
5948{
5949 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlErrorData> {
5950 self.into()
5951 }
5952}
5953impl flutter_rust_bridge::IntoDart for crate::model::LnUrlInfo {
5955 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5956 [
5957 self.ln_address.into_into_dart().into_dart(),
5958 self.lnurl_pay_comment.into_into_dart().into_dart(),
5959 self.lnurl_pay_domain.into_into_dart().into_dart(),
5960 self.lnurl_pay_metadata.into_into_dart().into_dart(),
5961 self.lnurl_pay_success_action.into_into_dart().into_dart(),
5962 self.lnurl_pay_unprocessed_success_action
5963 .into_into_dart()
5964 .into_dart(),
5965 self.lnurl_withdraw_endpoint.into_into_dart().into_dart(),
5966 ]
5967 .into_dart()
5968 }
5969}
5970impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlInfo {}
5971impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlInfo> for crate::model::LnUrlInfo {
5972 fn into_into_dart(self) -> crate::model::LnUrlInfo {
5973 self
5974 }
5975}
5976impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlPayError {
5978 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5979 match self {
5980 crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => [0.into_dart()].into_dart(),
5981 crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
5982 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5983 }
5984 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
5985 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5986 }
5987 crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
5988 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
5989 }
5990 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
5991 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
5992 }
5993 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
5994 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
5995 }
5996 crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
5997 [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
5998 }
5999 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
6000 [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
6001 }
6002 crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
6003 [8.into_dart(), err.into_into_dart().into_dart()].into_dart()
6004 }
6005 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
6006 [9.into_dart(), err.into_into_dart().into_dart()].into_dart()
6007 }
6008 crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
6009 [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6010 }
6011 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
6012 [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6013 }
6014 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
6015 [12.into_dart(), err.into_into_dart().into_dart()].into_dart()
6016 }
6017 _ => {
6018 unimplemented!("");
6019 }
6020 }
6021 }
6022}
6023impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6024 for crate::bindings::duplicates::LnUrlPayError
6025{
6026}
6027impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlPayError>
6028 for crate::bindings::duplicates::LnUrlPayError
6029{
6030 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlPayError {
6031 self
6032 }
6033}
6034impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6036 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6037 [
6038 self.0.payment_hash.into_into_dart().into_dart(),
6039 self.0.reason.into_into_dart().into_dart(),
6040 ]
6041 .into_dart()
6042 }
6043}
6044impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6045 for FrbWrapper<crate::bindings::LnUrlPayErrorData>
6046{
6047}
6048impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayErrorData>>
6049 for crate::bindings::LnUrlPayErrorData
6050{
6051 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6052 self.into()
6053 }
6054}
6055impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayRequest {
6057 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6058 [self.prepare_response.into_into_dart().into_dart()].into_dart()
6059 }
6060}
6061impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayRequest {}
6062impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayRequest>
6063 for crate::model::LnUrlPayRequest
6064{
6065 fn into_into_dart(self) -> crate::model::LnUrlPayRequest {
6066 self
6067 }
6068}
6069impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6071 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6072 [
6073 self.0.callback.into_into_dart().into_dart(),
6074 self.0.min_sendable.into_into_dart().into_dart(),
6075 self.0.max_sendable.into_into_dart().into_dart(),
6076 self.0.metadata_str.into_into_dart().into_dart(),
6077 self.0.comment_allowed.into_into_dart().into_dart(),
6078 self.0.domain.into_into_dart().into_dart(),
6079 self.0.allows_nostr.into_into_dart().into_dart(),
6080 self.0.nostr_pubkey.into_into_dart().into_dart(),
6081 self.0.ln_address.into_into_dart().into_dart(),
6082 ]
6083 .into_dart()
6084 }
6085}
6086impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6087 for FrbWrapper<crate::bindings::LnUrlPayRequestData>
6088{
6089}
6090impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayRequestData>>
6091 for crate::bindings::LnUrlPayRequestData
6092{
6093 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6094 self.into()
6095 }
6096}
6097impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayResult {
6099 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6100 match self {
6101 crate::model::LnUrlPayResult::EndpointSuccess { data } => {
6102 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6103 }
6104 crate::model::LnUrlPayResult::EndpointError { data } => {
6105 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6106 }
6107 crate::model::LnUrlPayResult::PayError { data } => {
6108 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6109 }
6110 _ => {
6111 unimplemented!("");
6112 }
6113 }
6114 }
6115}
6116impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayResult {}
6117impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayResult>
6118 for crate::model::LnUrlPayResult
6119{
6120 fn into_into_dart(self) -> crate::model::LnUrlPayResult {
6121 self
6122 }
6123}
6124impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPaySuccessData {
6126 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6127 [
6128 self.payment.into_into_dart().into_dart(),
6129 self.success_action.into_into_dart().into_dart(),
6130 ]
6131 .into_dart()
6132 }
6133}
6134impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6135 for crate::model::LnUrlPaySuccessData
6136{
6137}
6138impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPaySuccessData>
6139 for crate::model::LnUrlPaySuccessData
6140{
6141 fn into_into_dart(self) -> crate::model::LnUrlPaySuccessData {
6142 self
6143 }
6144}
6145impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawError {
6147 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6148 match self {
6149 crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
6150 [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
6151 }
6152 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
6153 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
6154 }
6155 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
6156 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
6157 }
6158 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
6159 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
6160 }
6161 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
6162 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6163 }
6164 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
6165 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6166 }
6167 _ => {
6168 unimplemented!("");
6169 }
6170 }
6171 }
6172}
6173impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6174 for crate::bindings::duplicates::LnUrlWithdrawError
6175{
6176}
6177impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawError>
6178 for crate::bindings::duplicates::LnUrlWithdrawError
6179{
6180 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
6181 self
6182 }
6183}
6184impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6186 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6187 [
6188 self.0.data.into_into_dart().into_dart(),
6189 self.0.amount_msat.into_into_dart().into_dart(),
6190 self.0.description.into_into_dart().into_dart(),
6191 ]
6192 .into_dart()
6193 }
6194}
6195impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6196 for FrbWrapper<crate::bindings::LnUrlWithdrawRequest>
6197{
6198}
6199impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequest>>
6200 for crate::bindings::LnUrlWithdrawRequest
6201{
6202 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6203 self.into()
6204 }
6205}
6206impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6208 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6209 [
6210 self.0.callback.into_into_dart().into_dart(),
6211 self.0.k1.into_into_dart().into_dart(),
6212 self.0.default_description.into_into_dart().into_dart(),
6213 self.0.min_withdrawable.into_into_dart().into_dart(),
6214 self.0.max_withdrawable.into_into_dart().into_dart(),
6215 ]
6216 .into_dart()
6217 }
6218}
6219impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6220 for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>
6221{
6222}
6223impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>>
6224 for crate::bindings::LnUrlWithdrawRequestData
6225{
6226 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6227 self.into()
6228 }
6229}
6230impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawResult {
6232 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6233 match self {
6234 crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
6235 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6236 }
6237 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
6238 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6239 }
6240 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
6241 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6242 }
6243 _ => {
6244 unimplemented!("");
6245 }
6246 }
6247 }
6248}
6249impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6250 for crate::bindings::duplicates::LnUrlWithdrawResult
6251{
6252}
6253impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawResult>
6254 for crate::bindings::duplicates::LnUrlWithdrawResult
6255{
6256 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
6257 self
6258 }
6259}
6260impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6262 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6263 [self.invoice.into_into_dart().into_dart()].into_dart()
6264 }
6265}
6266impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6267 for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6268{
6269}
6270impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
6271 for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6272{
6273 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6274 self
6275 }
6276}
6277impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocaleOverrides> {
6279 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6280 [
6281 self.0.locale.into_into_dart().into_dart(),
6282 self.0.spacing.into_into_dart().into_dart(),
6283 self.0.symbol.into_into_dart().into_dart(),
6284 ]
6285 .into_dart()
6286 }
6287}
6288impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6289 for FrbWrapper<crate::bindings::LocaleOverrides>
6290{
6291}
6292impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocaleOverrides>>
6293 for crate::bindings::LocaleOverrides
6294{
6295 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocaleOverrides> {
6296 self.into()
6297 }
6298}
6299impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocalizedName> {
6301 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6302 [
6303 self.0.locale.into_into_dart().into_dart(),
6304 self.0.name.into_into_dart().into_dart(),
6305 ]
6306 .into_dart()
6307 }
6308}
6309impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6310 for FrbWrapper<crate::bindings::LocalizedName>
6311{
6312}
6313impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocalizedName>>
6314 for crate::bindings::LocalizedName
6315{
6316 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocalizedName> {
6317 self.into()
6318 }
6319}
6320impl flutter_rust_bridge::IntoDart for crate::model::LogEntry {
6322 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6323 [
6324 self.line.into_into_dart().into_dart(),
6325 self.level.into_into_dart().into_dart(),
6326 ]
6327 .into_dart()
6328 }
6329}
6330impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LogEntry {}
6331impl flutter_rust_bridge::IntoIntoDart<crate::model::LogEntry> for crate::model::LogEntry {
6332 fn into_into_dart(self) -> crate::model::LogEntry {
6333 self
6334 }
6335}
6336impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::MessageSuccessActionData> {
6338 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6339 [self.0.message.into_into_dart().into_dart()].into_dart()
6340 }
6341}
6342impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6343 for FrbWrapper<crate::bindings::MessageSuccessActionData>
6344{
6345}
6346impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::MessageSuccessActionData>>
6347 for crate::bindings::MessageSuccessActionData
6348{
6349 fn into_into_dart(self) -> FrbWrapper<crate::bindings::MessageSuccessActionData> {
6350 self.into()
6351 }
6352}
6353impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Network> {
6355 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6356 match self.0 {
6357 crate::bindings::Network::Bitcoin => 0.into_dart(),
6358 crate::bindings::Network::Testnet => 1.into_dart(),
6359 crate::bindings::Network::Signet => 2.into_dart(),
6360 crate::bindings::Network::Regtest => 3.into_dart(),
6361 _ => unreachable!(),
6362 }
6363 }
6364}
6365impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6366 for FrbWrapper<crate::bindings::Network>
6367{
6368}
6369impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Network>>
6370 for crate::bindings::Network
6371{
6372 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Network> {
6373 self.into()
6374 }
6375}
6376impl flutter_rust_bridge::IntoDart for crate::model::OnchainPaymentLimitsResponse {
6378 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6379 [
6380 self.send.into_into_dart().into_dart(),
6381 self.receive.into_into_dart().into_dart(),
6382 ]
6383 .into_dart()
6384 }
6385}
6386impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6387 for crate::model::OnchainPaymentLimitsResponse
6388{
6389}
6390impl flutter_rust_bridge::IntoIntoDart<crate::model::OnchainPaymentLimitsResponse>
6391 for crate::model::OnchainPaymentLimitsResponse
6392{
6393 fn into_into_dart(self) -> crate::model::OnchainPaymentLimitsResponse {
6394 self
6395 }
6396}
6397impl flutter_rust_bridge::IntoDart for crate::model::PayAmount {
6399 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6400 match self {
6401 crate::model::PayAmount::Bitcoin {
6402 receiver_amount_sat,
6403 } => [
6404 0.into_dart(),
6405 receiver_amount_sat.into_into_dart().into_dart(),
6406 ]
6407 .into_dart(),
6408 crate::model::PayAmount::Asset {
6409 to_asset,
6410 receiver_amount,
6411 estimate_asset_fees,
6412 from_asset,
6413 } => [
6414 1.into_dart(),
6415 to_asset.into_into_dart().into_dart(),
6416 receiver_amount.into_into_dart().into_dart(),
6417 estimate_asset_fees.into_into_dart().into_dart(),
6418 from_asset.into_into_dart().into_dart(),
6419 ]
6420 .into_dart(),
6421 crate::model::PayAmount::Drain => [2.into_dart()].into_dart(),
6422 _ => {
6423 unimplemented!("");
6424 }
6425 }
6426 }
6427}
6428impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PayAmount {}
6429impl flutter_rust_bridge::IntoIntoDart<crate::model::PayAmount> for crate::model::PayAmount {
6430 fn into_into_dart(self) -> crate::model::PayAmount {
6431 self
6432 }
6433}
6434impl flutter_rust_bridge::IntoDart for crate::model::PayOnchainRequest {
6436 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6437 [
6438 self.address.into_into_dart().into_dart(),
6439 self.prepare_response.into_into_dart().into_dart(),
6440 ]
6441 .into_dart()
6442 }
6443}
6444impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6445 for crate::model::PayOnchainRequest
6446{
6447}
6448impl flutter_rust_bridge::IntoIntoDart<crate::model::PayOnchainRequest>
6449 for crate::model::PayOnchainRequest
6450{
6451 fn into_into_dart(self) -> crate::model::PayOnchainRequest {
6452 self
6453 }
6454}
6455impl flutter_rust_bridge::IntoDart for crate::model::Payment {
6457 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6458 [
6459 self.destination.into_into_dart().into_dart(),
6460 self.tx_id.into_into_dart().into_dart(),
6461 self.unblinding_data.into_into_dart().into_dart(),
6462 self.timestamp.into_into_dart().into_dart(),
6463 self.amount_sat.into_into_dart().into_dart(),
6464 self.fees_sat.into_into_dart().into_dart(),
6465 self.swapper_fees_sat.into_into_dart().into_dart(),
6466 self.payment_type.into_into_dart().into_dart(),
6467 self.status.into_into_dart().into_dart(),
6468 self.details.into_into_dart().into_dart(),
6469 ]
6470 .into_dart()
6471 }
6472}
6473impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Payment {}
6474impl flutter_rust_bridge::IntoIntoDart<crate::model::Payment> for crate::model::Payment {
6475 fn into_into_dart(self) -> crate::model::Payment {
6476 self
6477 }
6478}
6479impl flutter_rust_bridge::IntoDart for crate::model::PaymentDetails {
6481 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6482 match self {
6483 crate::model::PaymentDetails::Lightning {
6484 swap_id,
6485 description,
6486 liquid_expiration_blockheight,
6487 preimage,
6488 invoice,
6489 bolt12_offer,
6490 payment_hash,
6491 destination_pubkey,
6492 lnurl_info,
6493 bip353_address,
6494 payer_note,
6495 claim_tx_id,
6496 refund_tx_id,
6497 refund_tx_amount_sat,
6498 } => [
6499 0.into_dart(),
6500 swap_id.into_into_dart().into_dart(),
6501 description.into_into_dart().into_dart(),
6502 liquid_expiration_blockheight.into_into_dart().into_dart(),
6503 preimage.into_into_dart().into_dart(),
6504 invoice.into_into_dart().into_dart(),
6505 bolt12_offer.into_into_dart().into_dart(),
6506 payment_hash.into_into_dart().into_dart(),
6507 destination_pubkey.into_into_dart().into_dart(),
6508 lnurl_info.into_into_dart().into_dart(),
6509 bip353_address.into_into_dart().into_dart(),
6510 payer_note.into_into_dart().into_dart(),
6511 claim_tx_id.into_into_dart().into_dart(),
6512 refund_tx_id.into_into_dart().into_dart(),
6513 refund_tx_amount_sat.into_into_dart().into_dart(),
6514 ]
6515 .into_dart(),
6516 crate::model::PaymentDetails::Liquid {
6517 destination,
6518 description,
6519 asset_id,
6520 asset_info,
6521 lnurl_info,
6522 bip353_address,
6523 payer_note,
6524 } => [
6525 1.into_dart(),
6526 destination.into_into_dart().into_dart(),
6527 description.into_into_dart().into_dart(),
6528 asset_id.into_into_dart().into_dart(),
6529 asset_info.into_into_dart().into_dart(),
6530 lnurl_info.into_into_dart().into_dart(),
6531 bip353_address.into_into_dart().into_dart(),
6532 payer_note.into_into_dart().into_dart(),
6533 ]
6534 .into_dart(),
6535 crate::model::PaymentDetails::Bitcoin {
6536 swap_id,
6537 bitcoin_address,
6538 description,
6539 auto_accepted_fees,
6540 liquid_expiration_blockheight,
6541 bitcoin_expiration_blockheight,
6542 lockup_tx_id,
6543 claim_tx_id,
6544 refund_tx_id,
6545 refund_tx_amount_sat,
6546 } => [
6547 2.into_dart(),
6548 swap_id.into_into_dart().into_dart(),
6549 bitcoin_address.into_into_dart().into_dart(),
6550 description.into_into_dart().into_dart(),
6551 auto_accepted_fees.into_into_dart().into_dart(),
6552 liquid_expiration_blockheight.into_into_dart().into_dart(),
6553 bitcoin_expiration_blockheight.into_into_dart().into_dart(),
6554 lockup_tx_id.into_into_dart().into_dart(),
6555 claim_tx_id.into_into_dart().into_dart(),
6556 refund_tx_id.into_into_dart().into_dart(),
6557 refund_tx_amount_sat.into_into_dart().into_dart(),
6558 ]
6559 .into_dart(),
6560 _ => {
6561 unimplemented!("");
6562 }
6563 }
6564 }
6565}
6566impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentDetails {}
6567impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentDetails>
6568 for crate::model::PaymentDetails
6569{
6570 fn into_into_dart(self) -> crate::model::PaymentDetails {
6571 self
6572 }
6573}
6574impl flutter_rust_bridge::IntoDart for crate::error::PaymentError {
6576 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6577 match self {
6578 crate::error::PaymentError::AlreadyClaimed => [0.into_dart()].into_dart(),
6579 crate::error::PaymentError::AlreadyPaid => [1.into_dart()].into_dart(),
6580 crate::error::PaymentError::PaymentInProgress => [2.into_dart()].into_dart(),
6581 crate::error::PaymentError::AmountOutOfRange { min, max } => [
6582 3.into_dart(),
6583 min.into_into_dart().into_dart(),
6584 max.into_into_dart().into_dart(),
6585 ]
6586 .into_dart(),
6587 crate::error::PaymentError::AmountMissing { err } => {
6588 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6589 }
6590 crate::error::PaymentError::AssetError { err } => {
6591 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6592 }
6593 crate::error::PaymentError::InvalidNetwork { err } => {
6594 [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
6595 }
6596 crate::error::PaymentError::Generic { err } => {
6597 [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
6598 }
6599 crate::error::PaymentError::InvalidOrExpiredFees => [8.into_dart()].into_dart(),
6600 crate::error::PaymentError::InsufficientFunds => [9.into_dart()].into_dart(),
6601 crate::error::PaymentError::InvalidDescription { err } => {
6602 [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6603 }
6604 crate::error::PaymentError::InvalidInvoice { err } => {
6605 [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6606 }
6607 crate::error::PaymentError::InvalidPreimage => [12.into_dart()].into_dart(),
6608 crate::error::PaymentError::PairsNotFound => [13.into_dart()].into_dart(),
6609 crate::error::PaymentError::PaymentTimeout => [14.into_dart()].into_dart(),
6610 crate::error::PaymentError::PersistError => [15.into_dart()].into_dart(),
6611 crate::error::PaymentError::ReceiveError { err } => {
6612 [16.into_dart(), err.into_into_dart().into_dart()].into_dart()
6613 }
6614 crate::error::PaymentError::Refunded { err, refund_tx_id } => [
6615 17.into_dart(),
6616 err.into_into_dart().into_dart(),
6617 refund_tx_id.into_into_dart().into_dart(),
6618 ]
6619 .into_dart(),
6620 crate::error::PaymentError::SelfTransferNotSupported => [18.into_dart()].into_dart(),
6621 crate::error::PaymentError::SendError { err } => {
6622 [19.into_dart(), err.into_into_dart().into_dart()].into_dart()
6623 }
6624 crate::error::PaymentError::SignerError { err } => {
6625 [20.into_dart(), err.into_into_dart().into_dart()].into_dart()
6626 }
6627 _ => {
6628 unimplemented!("");
6629 }
6630 }
6631 }
6632}
6633impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::PaymentError {}
6634impl flutter_rust_bridge::IntoIntoDart<crate::error::PaymentError> for crate::error::PaymentError {
6635 fn into_into_dart(self) -> crate::error::PaymentError {
6636 self
6637 }
6638}
6639impl flutter_rust_bridge::IntoDart for crate::model::PaymentMethod {
6641 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6642 match self {
6643 Self::Lightning => 0.into_dart(),
6644 Self::Bolt11Invoice => 1.into_dart(),
6645 Self::Bolt12Offer => 2.into_dart(),
6646 Self::BitcoinAddress => 3.into_dart(),
6647 Self::LiquidAddress => 4.into_dart(),
6648 _ => unreachable!(),
6649 }
6650 }
6651}
6652impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentMethod {}
6653impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentMethod>
6654 for crate::model::PaymentMethod
6655{
6656 fn into_into_dart(self) -> crate::model::PaymentMethod {
6657 self
6658 }
6659}
6660impl flutter_rust_bridge::IntoDart for crate::model::PaymentState {
6662 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6663 match self {
6664 Self::Created => 0.into_dart(),
6665 Self::Pending => 1.into_dart(),
6666 Self::Complete => 2.into_dart(),
6667 Self::Failed => 3.into_dart(),
6668 Self::TimedOut => 4.into_dart(),
6669 Self::Refundable => 5.into_dart(),
6670 Self::RefundPending => 6.into_dart(),
6671 Self::WaitingFeeAcceptance => 7.into_dart(),
6672 _ => unreachable!(),
6673 }
6674 }
6675}
6676impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentState {}
6677impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentState> for crate::model::PaymentState {
6678 fn into_into_dart(self) -> crate::model::PaymentState {
6679 self
6680 }
6681}
6682impl flutter_rust_bridge::IntoDart for crate::model::PaymentType {
6684 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6685 match self {
6686 Self::Receive => 0.into_dart(),
6687 Self::Send => 1.into_dart(),
6688 _ => unreachable!(),
6689 }
6690 }
6691}
6692impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentType {}
6693impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentType> for crate::model::PaymentType {
6694 fn into_into_dart(self) -> crate::model::PaymentType {
6695 self
6696 }
6697}
6698impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinRequest {
6700 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6701 [
6702 self.provider.into_into_dart().into_dart(),
6703 self.amount_sat.into_into_dart().into_dart(),
6704 ]
6705 .into_dart()
6706 }
6707}
6708impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6709 for crate::model::PrepareBuyBitcoinRequest
6710{
6711}
6712impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinRequest>
6713 for crate::model::PrepareBuyBitcoinRequest
6714{
6715 fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinRequest {
6716 self
6717 }
6718}
6719impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinResponse {
6721 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6722 [
6723 self.provider.into_into_dart().into_dart(),
6724 self.amount_sat.into_into_dart().into_dart(),
6725 self.fees_sat.into_into_dart().into_dart(),
6726 ]
6727 .into_dart()
6728 }
6729}
6730impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6731 for crate::model::PrepareBuyBitcoinResponse
6732{
6733}
6734impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinResponse>
6735 for crate::model::PrepareBuyBitcoinResponse
6736{
6737 fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinResponse {
6738 self
6739 }
6740}
6741impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayRequest {
6743 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6744 [
6745 self.data.into_into_dart().into_dart(),
6746 self.amount.into_into_dart().into_dart(),
6747 self.bip353_address.into_into_dart().into_dart(),
6748 self.comment.into_into_dart().into_dart(),
6749 self.validate_success_action_url
6750 .into_into_dart()
6751 .into_dart(),
6752 ]
6753 .into_dart()
6754 }
6755}
6756impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6757 for crate::model::PrepareLnUrlPayRequest
6758{
6759}
6760impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayRequest>
6761 for crate::model::PrepareLnUrlPayRequest
6762{
6763 fn into_into_dart(self) -> crate::model::PrepareLnUrlPayRequest {
6764 self
6765 }
6766}
6767impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayResponse {
6769 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6770 [
6771 self.destination.into_into_dart().into_dart(),
6772 self.fees_sat.into_into_dart().into_dart(),
6773 self.data.into_into_dart().into_dart(),
6774 self.amount.into_into_dart().into_dart(),
6775 self.comment.into_into_dart().into_dart(),
6776 self.success_action.into_into_dart().into_dart(),
6777 ]
6778 .into_dart()
6779 }
6780}
6781impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6782 for crate::model::PrepareLnUrlPayResponse
6783{
6784}
6785impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayResponse>
6786 for crate::model::PrepareLnUrlPayResponse
6787{
6788 fn into_into_dart(self) -> crate::model::PrepareLnUrlPayResponse {
6789 self
6790 }
6791}
6792impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainRequest {
6794 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6795 [
6796 self.amount.into_into_dart().into_dart(),
6797 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6798 ]
6799 .into_dart()
6800 }
6801}
6802impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6803 for crate::model::PreparePayOnchainRequest
6804{
6805}
6806impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainRequest>
6807 for crate::model::PreparePayOnchainRequest
6808{
6809 fn into_into_dart(self) -> crate::model::PreparePayOnchainRequest {
6810 self
6811 }
6812}
6813impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainResponse {
6815 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6816 [
6817 self.receiver_amount_sat.into_into_dart().into_dart(),
6818 self.claim_fees_sat.into_into_dart().into_dart(),
6819 self.total_fees_sat.into_into_dart().into_dart(),
6820 ]
6821 .into_dart()
6822 }
6823}
6824impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6825 for crate::model::PreparePayOnchainResponse
6826{
6827}
6828impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainResponse>
6829 for crate::model::PreparePayOnchainResponse
6830{
6831 fn into_into_dart(self) -> crate::model::PreparePayOnchainResponse {
6832 self
6833 }
6834}
6835impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveRequest {
6837 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6838 [
6839 self.payment_method.into_into_dart().into_dart(),
6840 self.amount.into_into_dart().into_dart(),
6841 ]
6842 .into_dart()
6843 }
6844}
6845impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6846 for crate::model::PrepareReceiveRequest
6847{
6848}
6849impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveRequest>
6850 for crate::model::PrepareReceiveRequest
6851{
6852 fn into_into_dart(self) -> crate::model::PrepareReceiveRequest {
6853 self
6854 }
6855}
6856impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveResponse {
6858 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6859 [
6860 self.payment_method.into_into_dart().into_dart(),
6861 self.fees_sat.into_into_dart().into_dart(),
6862 self.amount.into_into_dart().into_dart(),
6863 self.min_payer_amount_sat.into_into_dart().into_dart(),
6864 self.max_payer_amount_sat.into_into_dart().into_dart(),
6865 self.swapper_feerate.into_into_dart().into_dart(),
6866 ]
6867 .into_dart()
6868 }
6869}
6870impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6871 for crate::model::PrepareReceiveResponse
6872{
6873}
6874impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveResponse>
6875 for crate::model::PrepareReceiveResponse
6876{
6877 fn into_into_dart(self) -> crate::model::PrepareReceiveResponse {
6878 self
6879 }
6880}
6881impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundRequest {
6883 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6884 [
6885 self.swap_address.into_into_dart().into_dart(),
6886 self.refund_address.into_into_dart().into_dart(),
6887 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6888 ]
6889 .into_dart()
6890 }
6891}
6892impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6893 for crate::model::PrepareRefundRequest
6894{
6895}
6896impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundRequest>
6897 for crate::model::PrepareRefundRequest
6898{
6899 fn into_into_dart(self) -> crate::model::PrepareRefundRequest {
6900 self
6901 }
6902}
6903impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundResponse {
6905 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6906 [
6907 self.tx_vsize.into_into_dart().into_dart(),
6908 self.tx_fee_sat.into_into_dart().into_dart(),
6909 self.last_refund_tx_id.into_into_dart().into_dart(),
6910 ]
6911 .into_dart()
6912 }
6913}
6914impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6915 for crate::model::PrepareRefundResponse
6916{
6917}
6918impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundResponse>
6919 for crate::model::PrepareRefundResponse
6920{
6921 fn into_into_dart(self) -> crate::model::PrepareRefundResponse {
6922 self
6923 }
6924}
6925impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendRequest {
6927 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6928 [
6929 self.destination.into_into_dart().into_dart(),
6930 self.amount.into_into_dart().into_dart(),
6931 ]
6932 .into_dart()
6933 }
6934}
6935impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6936 for crate::model::PrepareSendRequest
6937{
6938}
6939impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendRequest>
6940 for crate::model::PrepareSendRequest
6941{
6942 fn into_into_dart(self) -> crate::model::PrepareSendRequest {
6943 self
6944 }
6945}
6946impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendResponse {
6948 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6949 [
6950 self.destination.into_into_dart().into_dart(),
6951 self.amount.into_into_dart().into_dart(),
6952 self.fees_sat.into_into_dart().into_dart(),
6953 self.estimated_asset_fees.into_into_dart().into_dart(),
6954 self.exchange_amount_sat.into_into_dart().into_dart(),
6955 ]
6956 .into_dart()
6957 }
6958}
6959impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6960 for crate::model::PrepareSendResponse
6961{
6962}
6963impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendResponse>
6964 for crate::model::PrepareSendResponse
6965{
6966 fn into_into_dart(self) -> crate::model::PrepareSendResponse {
6967 self
6968 }
6969}
6970impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Rate> {
6972 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6973 [
6974 self.0.coin.into_into_dart().into_dart(),
6975 self.0.value.into_into_dart().into_dart(),
6976 ]
6977 .into_dart()
6978 }
6979}
6980impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6981 for FrbWrapper<crate::bindings::Rate>
6982{
6983}
6984impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Rate>>
6985 for crate::bindings::Rate
6986{
6987 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Rate> {
6988 self.into()
6989 }
6990}
6991impl flutter_rust_bridge::IntoDart for crate::model::ReceiveAmount {
6993 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6994 match self {
6995 crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
6996 [0.into_dart(), payer_amount_sat.into_into_dart().into_dart()].into_dart()
6997 }
6998 crate::model::ReceiveAmount::Asset {
6999 asset_id,
7000 payer_amount,
7001 } => [
7002 1.into_dart(),
7003 asset_id.into_into_dart().into_dart(),
7004 payer_amount.into_into_dart().into_dart(),
7005 ]
7006 .into_dart(),
7007 _ => {
7008 unimplemented!("");
7009 }
7010 }
7011 }
7012}
7013impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ReceiveAmount {}
7014impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceiveAmount>
7015 for crate::model::ReceiveAmount
7016{
7017 fn into_into_dart(self) -> crate::model::ReceiveAmount {
7018 self
7019 }
7020}
7021impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentRequest {
7023 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7024 [
7025 self.prepare_response.into_into_dart().into_dart(),
7026 self.description.into_into_dart().into_dart(),
7027 self.use_description_hash.into_into_dart().into_dart(),
7028 self.payer_note.into_into_dart().into_dart(),
7029 ]
7030 .into_dart()
7031 }
7032}
7033impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7034 for crate::model::ReceivePaymentRequest
7035{
7036}
7037impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentRequest>
7038 for crate::model::ReceivePaymentRequest
7039{
7040 fn into_into_dart(self) -> crate::model::ReceivePaymentRequest {
7041 self
7042 }
7043}
7044impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentResponse {
7046 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7047 [self.destination.into_into_dart().into_dart()].into_dart()
7048 }
7049}
7050impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7051 for crate::model::ReceivePaymentResponse
7052{
7053}
7054impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentResponse>
7055 for crate::model::ReceivePaymentResponse
7056{
7057 fn into_into_dart(self) -> crate::model::ReceivePaymentResponse {
7058 self
7059 }
7060}
7061impl flutter_rust_bridge::IntoDart for crate::model::RecommendedFees {
7063 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7064 [
7065 self.fastest_fee.into_into_dart().into_dart(),
7066 self.half_hour_fee.into_into_dart().into_dart(),
7067 self.hour_fee.into_into_dart().into_dart(),
7068 self.economy_fee.into_into_dart().into_dart(),
7069 self.minimum_fee.into_into_dart().into_dart(),
7070 ]
7071 .into_dart()
7072 }
7073}
7074impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RecommendedFees {}
7075impl flutter_rust_bridge::IntoIntoDart<crate::model::RecommendedFees>
7076 for crate::model::RecommendedFees
7077{
7078 fn into_into_dart(self) -> crate::model::RecommendedFees {
7079 self
7080 }
7081}
7082impl flutter_rust_bridge::IntoDart for crate::model::RefundRequest {
7084 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7085 [
7086 self.swap_address.into_into_dart().into_dart(),
7087 self.refund_address.into_into_dart().into_dart(),
7088 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
7089 ]
7090 .into_dart()
7091 }
7092}
7093impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundRequest {}
7094impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundRequest>
7095 for crate::model::RefundRequest
7096{
7097 fn into_into_dart(self) -> crate::model::RefundRequest {
7098 self
7099 }
7100}
7101impl flutter_rust_bridge::IntoDart for crate::model::RefundResponse {
7103 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7104 [self.refund_tx_id.into_into_dart().into_dart()].into_dart()
7105 }
7106}
7107impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundResponse {}
7108impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundResponse>
7109 for crate::model::RefundResponse
7110{
7111 fn into_into_dart(self) -> crate::model::RefundResponse {
7112 self
7113 }
7114}
7115impl flutter_rust_bridge::IntoDart for crate::model::RefundableSwap {
7117 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7118 [
7119 self.swap_address.into_into_dart().into_dart(),
7120 self.timestamp.into_into_dart().into_dart(),
7121 self.amount_sat.into_into_dart().into_dart(),
7122 self.last_refund_tx_id.into_into_dart().into_dart(),
7123 ]
7124 .into_dart()
7125 }
7126}
7127impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundableSwap {}
7128impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundableSwap>
7129 for crate::model::RefundableSwap
7130{
7131 fn into_into_dart(self) -> crate::model::RefundableSwap {
7132 self
7133 }
7134}
7135impl flutter_rust_bridge::IntoDart for crate::model::RestoreRequest {
7137 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7138 [self.backup_path.into_into_dart().into_dart()].into_dart()
7139 }
7140}
7141impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RestoreRequest {}
7142impl flutter_rust_bridge::IntoIntoDart<crate::model::RestoreRequest>
7143 for crate::model::RestoreRequest
7144{
7145 fn into_into_dart(self) -> crate::model::RestoreRequest {
7146 self
7147 }
7148}
7149impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHint> {
7151 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7152 [self.0.hops.into_into_dart().into_dart()].into_dart()
7153 }
7154}
7155impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7156 for FrbWrapper<crate::bindings::RouteHint>
7157{
7158}
7159impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHint>>
7160 for crate::bindings::RouteHint
7161{
7162 fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHint> {
7163 self.into()
7164 }
7165}
7166impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHintHop> {
7168 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7169 [
7170 self.0.src_node_id.into_into_dart().into_dart(),
7171 self.0.short_channel_id.into_into_dart().into_dart(),
7172 self.0.fees_base_msat.into_into_dart().into_dart(),
7173 self.0
7174 .fees_proportional_millionths
7175 .into_into_dart()
7176 .into_dart(),
7177 self.0.cltv_expiry_delta.into_into_dart().into_dart(),
7178 self.0.htlc_minimum_msat.into_into_dart().into_dart(),
7179 self.0.htlc_maximum_msat.into_into_dart().into_dart(),
7180 ]
7181 .into_dart()
7182 }
7183}
7184impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7185 for FrbWrapper<crate::bindings::RouteHintHop>
7186{
7187}
7188impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHintHop>>
7189 for crate::bindings::RouteHintHop
7190{
7191 fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHintHop> {
7192 self.into()
7193 }
7194}
7195impl flutter_rust_bridge::IntoDart for crate::error::SdkError {
7197 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7198 match self {
7199 crate::error::SdkError::AlreadyStarted => [0.into_dart()].into_dart(),
7200 crate::error::SdkError::Generic { err } => {
7201 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
7202 }
7203 crate::error::SdkError::NotStarted => [2.into_dart()].into_dart(),
7204 crate::error::SdkError::ServiceConnectivity { err } => {
7205 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
7206 }
7207 _ => {
7208 unimplemented!("");
7209 }
7210 }
7211 }
7212}
7213impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::SdkError {}
7214impl flutter_rust_bridge::IntoIntoDart<crate::error::SdkError> for crate::error::SdkError {
7215 fn into_into_dart(self) -> crate::error::SdkError {
7216 self
7217 }
7218}
7219impl flutter_rust_bridge::IntoDart for crate::model::SdkEvent {
7221 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7222 match self {
7223 crate::model::SdkEvent::PaymentFailed { details } => {
7224 [0.into_dart(), details.into_into_dart().into_dart()].into_dart()
7225 }
7226 crate::model::SdkEvent::PaymentPending { details } => {
7227 [1.into_dart(), details.into_into_dart().into_dart()].into_dart()
7228 }
7229 crate::model::SdkEvent::PaymentRefundable { details } => {
7230 [2.into_dart(), details.into_into_dart().into_dart()].into_dart()
7231 }
7232 crate::model::SdkEvent::PaymentRefunded { details } => {
7233 [3.into_dart(), details.into_into_dart().into_dart()].into_dart()
7234 }
7235 crate::model::SdkEvent::PaymentRefundPending { details } => {
7236 [4.into_dart(), details.into_into_dart().into_dart()].into_dart()
7237 }
7238 crate::model::SdkEvent::PaymentSucceeded { details } => {
7239 [5.into_dart(), details.into_into_dart().into_dart()].into_dart()
7240 }
7241 crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
7242 [6.into_dart(), details.into_into_dart().into_dart()].into_dart()
7243 }
7244 crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
7245 [7.into_dart(), details.into_into_dart().into_dart()].into_dart()
7246 }
7247 crate::model::SdkEvent::Synced => [8.into_dart()].into_dart(),
7248 crate::model::SdkEvent::DataSynced {
7249 did_pull_new_records,
7250 } => [
7251 9.into_dart(),
7252 did_pull_new_records.into_into_dart().into_dart(),
7253 ]
7254 .into_dart(),
7255 _ => {
7256 unimplemented!("");
7257 }
7258 }
7259 }
7260}
7261impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SdkEvent {}
7262impl flutter_rust_bridge::IntoIntoDart<crate::model::SdkEvent> for crate::model::SdkEvent {
7263 fn into_into_dart(self) -> crate::model::SdkEvent {
7264 self
7265 }
7266}
7267impl flutter_rust_bridge::IntoDart for crate::model::SendDestination {
7269 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7270 match self {
7271 crate::model::SendDestination::LiquidAddress {
7272 address_data,
7273 bip353_address,
7274 } => [
7275 0.into_dart(),
7276 address_data.into_into_dart().into_dart(),
7277 bip353_address.into_into_dart().into_dart(),
7278 ]
7279 .into_dart(),
7280 crate::model::SendDestination::Bolt11 {
7281 invoice,
7282 bip353_address,
7283 } => [
7284 1.into_dart(),
7285 invoice.into_into_dart().into_dart(),
7286 bip353_address.into_into_dart().into_dart(),
7287 ]
7288 .into_dart(),
7289 crate::model::SendDestination::Bolt12 {
7290 offer,
7291 receiver_amount_sat,
7292 bip353_address,
7293 } => [
7294 2.into_dart(),
7295 offer.into_into_dart().into_dart(),
7296 receiver_amount_sat.into_into_dart().into_dart(),
7297 bip353_address.into_into_dart().into_dart(),
7298 ]
7299 .into_dart(),
7300 _ => {
7301 unimplemented!("");
7302 }
7303 }
7304 }
7305}
7306impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SendDestination {}
7307impl flutter_rust_bridge::IntoIntoDart<crate::model::SendDestination>
7308 for crate::model::SendDestination
7309{
7310 fn into_into_dart(self) -> crate::model::SendDestination {
7311 self
7312 }
7313}
7314impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentRequest {
7316 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7317 [
7318 self.prepare_response.into_into_dart().into_dart(),
7319 self.use_asset_fees.into_into_dart().into_dart(),
7320 self.payer_note.into_into_dart().into_dart(),
7321 ]
7322 .into_dart()
7323 }
7324}
7325impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7326 for crate::model::SendPaymentRequest
7327{
7328}
7329impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentRequest>
7330 for crate::model::SendPaymentRequest
7331{
7332 fn into_into_dart(self) -> crate::model::SendPaymentRequest {
7333 self
7334 }
7335}
7336impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentResponse {
7338 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7339 [self.payment.into_into_dart().into_dart()].into_dart()
7340 }
7341}
7342impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7343 for crate::model::SendPaymentResponse
7344{
7345}
7346impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentResponse>
7347 for crate::model::SendPaymentResponse
7348{
7349 fn into_into_dart(self) -> crate::model::SendPaymentResponse {
7350 self
7351 }
7352}
7353impl flutter_rust_bridge::IntoDart for crate::model::SignMessageRequest {
7355 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7356 [self.message.into_into_dart().into_dart()].into_dart()
7357 }
7358}
7359impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7360 for crate::model::SignMessageRequest
7361{
7362}
7363impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageRequest>
7364 for crate::model::SignMessageRequest
7365{
7366 fn into_into_dart(self) -> crate::model::SignMessageRequest {
7367 self
7368 }
7369}
7370impl flutter_rust_bridge::IntoDart for crate::model::SignMessageResponse {
7372 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7373 [self.signature.into_into_dart().into_dart()].into_dart()
7374 }
7375}
7376impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7377 for crate::model::SignMessageResponse
7378{
7379}
7380impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageResponse>
7381 for crate::model::SignMessageResponse
7382{
7383 fn into_into_dart(self) -> crate::model::SignMessageResponse {
7384 self
7385 }
7386}
7387impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessAction> {
7389 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7390 match self.0 {
7391 crate::bindings::SuccessAction::Aes { data } => {
7392 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
7393 }
7394 crate::bindings::SuccessAction::Message { data } => {
7395 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7396 }
7397 crate::bindings::SuccessAction::Url { data } => {
7398 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7399 }
7400 _ => {
7401 unimplemented!("");
7402 }
7403 }
7404 }
7405}
7406impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7407 for FrbWrapper<crate::bindings::SuccessAction>
7408{
7409}
7410impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessAction>>
7411 for crate::bindings::SuccessAction
7412{
7413 fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessAction> {
7414 self.into()
7415 }
7416}
7417impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessActionProcessed> {
7419 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7420 match self.0 {
7421 crate::bindings::SuccessActionProcessed::Aes { result } => {
7422 [0.into_dart(), result.into_into_dart().into_dart()].into_dart()
7423 }
7424 crate::bindings::SuccessActionProcessed::Message { data } => {
7425 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7426 }
7427 crate::bindings::SuccessActionProcessed::Url { data } => {
7428 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7429 }
7430 _ => {
7431 unimplemented!("");
7432 }
7433 }
7434 }
7435}
7436impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7437 for FrbWrapper<crate::bindings::SuccessActionProcessed>
7438{
7439}
7440impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessActionProcessed>>
7441 for crate::bindings::SuccessActionProcessed
7442{
7443 fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessActionProcessed> {
7444 self.into()
7445 }
7446}
7447impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Symbol> {
7449 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7450 [
7451 self.0.grapheme.into_into_dart().into_dart(),
7452 self.0.template.into_into_dart().into_dart(),
7453 self.0.rtl.into_into_dart().into_dart(),
7454 self.0.position.into_into_dart().into_dart(),
7455 ]
7456 .into_dart()
7457 }
7458}
7459impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7460 for FrbWrapper<crate::bindings::Symbol>
7461{
7462}
7463impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Symbol>>
7464 for crate::bindings::Symbol
7465{
7466 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Symbol> {
7467 self.into()
7468 }
7469}
7470impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::UrlSuccessActionData> {
7472 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7473 [
7474 self.0.description.into_into_dart().into_dart(),
7475 self.0.url.into_into_dart().into_dart(),
7476 self.0.matches_callback_domain.into_into_dart().into_dart(),
7477 ]
7478 .into_dart()
7479 }
7480}
7481impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7482 for FrbWrapper<crate::bindings::UrlSuccessActionData>
7483{
7484}
7485impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::UrlSuccessActionData>>
7486 for crate::bindings::UrlSuccessActionData
7487{
7488 fn into_into_dart(self) -> FrbWrapper<crate::bindings::UrlSuccessActionData> {
7489 self.into()
7490 }
7491}
7492impl flutter_rust_bridge::IntoDart for crate::model::WalletInfo {
7494 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7495 [
7496 self.balance_sat.into_into_dart().into_dart(),
7497 self.pending_send_sat.into_into_dart().into_dart(),
7498 self.pending_receive_sat.into_into_dart().into_dart(),
7499 self.fingerprint.into_into_dart().into_dart(),
7500 self.pubkey.into_into_dart().into_dart(),
7501 self.asset_balances.into_into_dart().into_dart(),
7502 ]
7503 .into_dart()
7504 }
7505}
7506impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::WalletInfo {}
7507impl flutter_rust_bridge::IntoIntoDart<crate::model::WalletInfo> for crate::model::WalletInfo {
7508 fn into_into_dart(self) -> crate::model::WalletInfo {
7509 self
7510 }
7511}
7512
7513impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
7514 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7516 <String>::sse_encode(format!("{:?}", self), serializer);
7517 }
7518}
7519
7520impl SseEncode for BindingLiquidSdk {
7521 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7523 <RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer);
7524 }
7525}
7526
7527impl SseEncode
7528 for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
7529{
7530 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7532 let (ptr, size) = self.sse_encode_raw();
7533 <usize>::sse_encode(ptr, serializer);
7534 <i32>::sse_encode(size, serializer);
7535 }
7536}
7537
7538impl SseEncode
7539 for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
7540{
7541 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7543 unimplemented!("")
7544 }
7545}
7546
7547impl SseEncode
7548 for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
7549{
7550 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7552 unimplemented!("")
7553 }
7554}
7555
7556impl SseEncode for String {
7557 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7559 <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
7560 }
7561}
7562
7563impl SseEncode for crate::model::AcceptPaymentProposedFeesRequest {
7564 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7566 <crate::model::FetchPaymentProposedFeesResponse>::sse_encode(self.response, serializer);
7567 }
7568}
7569
7570impl SseEncode for crate::bindings::AesSuccessActionData {
7571 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7573 <String>::sse_encode(self.description, serializer);
7574 <String>::sse_encode(self.ciphertext, serializer);
7575 <String>::sse_encode(self.iv, serializer);
7576 }
7577}
7578
7579impl SseEncode for crate::bindings::AesSuccessActionDataDecrypted {
7580 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7582 <String>::sse_encode(self.description, serializer);
7583 <String>::sse_encode(self.plaintext, serializer);
7584 }
7585}
7586
7587impl SseEncode for crate::bindings::AesSuccessActionDataResult {
7588 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7590 match self {
7591 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
7592 <i32>::sse_encode(0, serializer);
7593 <crate::bindings::AesSuccessActionDataDecrypted>::sse_encode(data, serializer);
7594 }
7595 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
7596 <i32>::sse_encode(1, serializer);
7597 <String>::sse_encode(reason, serializer);
7598 }
7599 _ => {
7600 unimplemented!("");
7601 }
7602 }
7603 }
7604}
7605
7606impl SseEncode for crate::bindings::Amount {
7607 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7609 match self {
7610 crate::bindings::Amount::Bitcoin { amount_msat } => {
7611 <i32>::sse_encode(0, serializer);
7612 <u64>::sse_encode(amount_msat, serializer);
7613 }
7614 crate::bindings::Amount::Currency {
7615 iso4217_code,
7616 fractional_amount,
7617 } => {
7618 <i32>::sse_encode(1, serializer);
7619 <String>::sse_encode(iso4217_code, serializer);
7620 <u64>::sse_encode(fractional_amount, serializer);
7621 }
7622 _ => {
7623 unimplemented!("");
7624 }
7625 }
7626 }
7627}
7628
7629impl SseEncode for crate::model::AssetBalance {
7630 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7632 <String>::sse_encode(self.asset_id, serializer);
7633 <u64>::sse_encode(self.balance_sat, serializer);
7634 <Option<String>>::sse_encode(self.name, serializer);
7635 <Option<String>>::sse_encode(self.ticker, serializer);
7636 <Option<f64>>::sse_encode(self.balance, serializer);
7637 }
7638}
7639
7640impl SseEncode for crate::model::AssetInfo {
7641 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7643 <String>::sse_encode(self.name, serializer);
7644 <String>::sse_encode(self.ticker, serializer);
7645 <f64>::sse_encode(self.amount, serializer);
7646 <Option<f64>>::sse_encode(self.fees, serializer);
7647 }
7648}
7649
7650impl SseEncode for crate::model::AssetMetadata {
7651 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7653 <String>::sse_encode(self.asset_id, serializer);
7654 <String>::sse_encode(self.name, serializer);
7655 <String>::sse_encode(self.ticker, serializer);
7656 <u8>::sse_encode(self.precision, serializer);
7657 <Option<String>>::sse_encode(self.fiat_id, serializer);
7658 }
7659}
7660
7661impl SseEncode for crate::model::BackupRequest {
7662 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7664 <Option<String>>::sse_encode(self.backup_path, serializer);
7665 }
7666}
7667
7668impl SseEncode for crate::bindings::BindingEventListener {
7669 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7671 <StreamSink<crate::model::SdkEvent,flutter_rust_bridge::for_generated::DcoCodec>>::sse_encode(self.stream, serializer);
7672 }
7673}
7674
7675impl SseEncode for crate::bindings::BitcoinAddressData {
7676 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7678 <String>::sse_encode(self.address, serializer);
7679 <crate::bindings::Network>::sse_encode(self.network, serializer);
7680 <Option<u64>>::sse_encode(self.amount_sat, serializer);
7681 <Option<String>>::sse_encode(self.label, serializer);
7682 <Option<String>>::sse_encode(self.message, serializer);
7683 }
7684}
7685
7686impl SseEncode for crate::model::BlockchainExplorer {
7687 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7689 match self {
7690 crate::model::BlockchainExplorer::Electrum { url } => {
7691 <i32>::sse_encode(0, serializer);
7692 <String>::sse_encode(url, serializer);
7693 }
7694 crate::model::BlockchainExplorer::Esplora {
7695 url,
7696 use_waterfalls,
7697 } => {
7698 <i32>::sse_encode(1, serializer);
7699 <String>::sse_encode(url, serializer);
7700 <bool>::sse_encode(use_waterfalls, serializer);
7701 }
7702 _ => {
7703 unimplemented!("");
7704 }
7705 }
7706 }
7707}
7708
7709impl SseEncode for crate::model::BlockchainInfo {
7710 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7712 <u32>::sse_encode(self.liquid_tip, serializer);
7713 <u32>::sse_encode(self.bitcoin_tip, serializer);
7714 }
7715}
7716
7717impl SseEncode for bool {
7718 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7720 serializer.cursor.write_u8(self as _).unwrap();
7721 }
7722}
7723
7724impl SseEncode for crate::model::BuyBitcoinProvider {
7725 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7727 <i32>::sse_encode(
7728 match self {
7729 crate::model::BuyBitcoinProvider::Moonpay => 0,
7730 _ => {
7731 unimplemented!("");
7732 }
7733 },
7734 serializer,
7735 );
7736 }
7737}
7738
7739impl SseEncode for crate::model::BuyBitcoinRequest {
7740 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7742 <crate::model::PrepareBuyBitcoinResponse>::sse_encode(self.prepare_response, serializer);
7743 <Option<String>>::sse_encode(self.redirect_url, serializer);
7744 }
7745}
7746
7747impl SseEncode for crate::model::CheckMessageRequest {
7748 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7750 <String>::sse_encode(self.message, serializer);
7751 <String>::sse_encode(self.pubkey, serializer);
7752 <String>::sse_encode(self.signature, serializer);
7753 }
7754}
7755
7756impl SseEncode for crate::model::CheckMessageResponse {
7757 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7759 <bool>::sse_encode(self.is_valid, serializer);
7760 }
7761}
7762
7763impl SseEncode for crate::model::Config {
7764 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7766 <crate::model::BlockchainExplorer>::sse_encode(self.liquid_explorer, serializer);
7767 <crate::model::BlockchainExplorer>::sse_encode(self.bitcoin_explorer, serializer);
7768 <String>::sse_encode(self.working_dir, serializer);
7769 <crate::model::LiquidNetwork>::sse_encode(self.network, serializer);
7770 <u64>::sse_encode(self.payment_timeout_sec, serializer);
7771 <Option<String>>::sse_encode(self.sync_service_url, serializer);
7772 <Option<u64>>::sse_encode(self.zero_conf_max_amount_sat, serializer);
7773 <Option<String>>::sse_encode(self.breez_api_key, serializer);
7774 <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_encode(
7775 self.external_input_parsers,
7776 serializer,
7777 );
7778 <bool>::sse_encode(self.use_default_external_input_parsers, serializer);
7779 <Option<u64>>::sse_encode(self.onchain_fee_rate_leeway_sat, serializer);
7780 <Option<Vec<crate::model::AssetMetadata>>>::sse_encode(self.asset_metadata, serializer);
7781 <Option<String>>::sse_encode(self.sideswap_api_key, serializer);
7782 <bool>::sse_encode(self.use_magic_routing_hints, serializer);
7783 }
7784}
7785
7786impl SseEncode for crate::model::ConnectRequest {
7787 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7789 <crate::model::Config>::sse_encode(self.config, serializer);
7790 <Option<String>>::sse_encode(self.mnemonic, serializer);
7791 <Option<String>>::sse_encode(self.passphrase, serializer);
7792 <Option<Vec<u8>>>::sse_encode(self.seed, serializer);
7793 }
7794}
7795
7796impl SseEncode for crate::model::CreateBolt12InvoiceRequest {
7797 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7799 <String>::sse_encode(self.offer, serializer);
7800 <String>::sse_encode(self.invoice_request, serializer);
7801 }
7802}
7803
7804impl SseEncode for crate::model::CreateBolt12InvoiceResponse {
7805 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7807 <String>::sse_encode(self.invoice, serializer);
7808 }
7809}
7810
7811impl SseEncode for crate::bindings::CurrencyInfo {
7812 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7814 <String>::sse_encode(self.name, serializer);
7815 <u32>::sse_encode(self.fraction_size, serializer);
7816 <Option<u32>>::sse_encode(self.spacing, serializer);
7817 <Option<crate::bindings::Symbol>>::sse_encode(self.symbol, serializer);
7818 <Option<crate::bindings::Symbol>>::sse_encode(self.uniq_symbol, serializer);
7819 <Vec<crate::bindings::LocalizedName>>::sse_encode(self.localized_name, serializer);
7820 <Vec<crate::bindings::LocaleOverrides>>::sse_encode(self.locale_overrides, serializer);
7821 }
7822}
7823
7824impl SseEncode for crate::bindings::ExternalInputParser {
7825 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7827 <String>::sse_encode(self.provider_id, serializer);
7828 <String>::sse_encode(self.input_regex, serializer);
7829 <String>::sse_encode(self.parser_url, serializer);
7830 }
7831}
7832
7833impl SseEncode for f64 {
7834 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7836 serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
7837 }
7838}
7839
7840impl SseEncode for crate::model::FetchPaymentProposedFeesRequest {
7841 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7843 <String>::sse_encode(self.swap_id, serializer);
7844 }
7845}
7846
7847impl SseEncode for crate::model::FetchPaymentProposedFeesResponse {
7848 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7850 <String>::sse_encode(self.swap_id, serializer);
7851 <u64>::sse_encode(self.fees_sat, serializer);
7852 <u64>::sse_encode(self.payer_amount_sat, serializer);
7853 <u64>::sse_encode(self.receiver_amount_sat, serializer);
7854 }
7855}
7856
7857impl SseEncode for crate::bindings::FiatCurrency {
7858 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7860 <String>::sse_encode(self.id, serializer);
7861 <crate::bindings::CurrencyInfo>::sse_encode(self.info, serializer);
7862 }
7863}
7864
7865impl SseEncode for crate::model::GetInfoResponse {
7866 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7868 <crate::model::WalletInfo>::sse_encode(self.wallet_info, serializer);
7869 <crate::model::BlockchainInfo>::sse_encode(self.blockchain_info, serializer);
7870 }
7871}
7872
7873impl SseEncode for crate::model::GetPaymentRequest {
7874 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7876 match self {
7877 crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
7878 <i32>::sse_encode(0, serializer);
7879 <String>::sse_encode(payment_hash, serializer);
7880 }
7881 crate::model::GetPaymentRequest::SwapId { swap_id } => {
7882 <i32>::sse_encode(1, serializer);
7883 <String>::sse_encode(swap_id, serializer);
7884 }
7885 _ => {
7886 unimplemented!("");
7887 }
7888 }
7889 }
7890}
7891
7892impl SseEncode for i32 {
7893 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7895 serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
7896 }
7897}
7898
7899impl SseEncode for i64 {
7900 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7902 serializer.cursor.write_i64::<NativeEndian>(self).unwrap();
7903 }
7904}
7905
7906impl SseEncode for crate::bindings::InputType {
7907 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7909 match self {
7910 crate::bindings::InputType::BitcoinAddress { address } => {
7911 <i32>::sse_encode(0, serializer);
7912 <crate::bindings::BitcoinAddressData>::sse_encode(address, serializer);
7913 }
7914 crate::bindings::InputType::LiquidAddress { address } => {
7915 <i32>::sse_encode(1, serializer);
7916 <crate::bindings::LiquidAddressData>::sse_encode(address, serializer);
7917 }
7918 crate::bindings::InputType::Bolt11 { invoice } => {
7919 <i32>::sse_encode(2, serializer);
7920 <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
7921 }
7922 crate::bindings::InputType::Bolt12Offer {
7923 offer,
7924 bip353_address,
7925 } => {
7926 <i32>::sse_encode(3, serializer);
7927 <crate::bindings::LNOffer>::sse_encode(offer, serializer);
7928 <Option<String>>::sse_encode(bip353_address, serializer);
7929 }
7930 crate::bindings::InputType::NodeId { node_id } => {
7931 <i32>::sse_encode(4, serializer);
7932 <String>::sse_encode(node_id, serializer);
7933 }
7934 crate::bindings::InputType::Url { url } => {
7935 <i32>::sse_encode(5, serializer);
7936 <String>::sse_encode(url, serializer);
7937 }
7938 crate::bindings::InputType::LnUrlPay {
7939 data,
7940 bip353_address,
7941 } => {
7942 <i32>::sse_encode(6, serializer);
7943 <crate::bindings::LnUrlPayRequestData>::sse_encode(data, serializer);
7944 <Option<String>>::sse_encode(bip353_address, serializer);
7945 }
7946 crate::bindings::InputType::LnUrlWithdraw { data } => {
7947 <i32>::sse_encode(7, serializer);
7948 <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(data, serializer);
7949 }
7950 crate::bindings::InputType::LnUrlAuth { data } => {
7951 <i32>::sse_encode(8, serializer);
7952 <crate::bindings::LnUrlAuthRequestData>::sse_encode(data, serializer);
7953 }
7954 crate::bindings::InputType::LnUrlError { data } => {
7955 <i32>::sse_encode(9, serializer);
7956 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
7957 }
7958 _ => {
7959 unimplemented!("");
7960 }
7961 }
7962 }
7963}
7964
7965impl SseEncode for crate::model::LightningPaymentLimitsResponse {
7966 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7968 <crate::model::Limits>::sse_encode(self.send, serializer);
7969 <crate::model::Limits>::sse_encode(self.receive, serializer);
7970 }
7971}
7972
7973impl SseEncode for crate::model::Limits {
7974 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7976 <u64>::sse_encode(self.min_sat, serializer);
7977 <u64>::sse_encode(self.max_sat, serializer);
7978 <u64>::sse_encode(self.max_zero_conf_sat, serializer);
7979 }
7980}
7981
7982impl SseEncode for crate::bindings::LiquidAddressData {
7983 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7985 <String>::sse_encode(self.address, serializer);
7986 <crate::bindings::Network>::sse_encode(self.network, serializer);
7987 <Option<String>>::sse_encode(self.asset_id, serializer);
7988 <Option<f64>>::sse_encode(self.amount, serializer);
7989 <Option<u64>>::sse_encode(self.amount_sat, serializer);
7990 <Option<String>>::sse_encode(self.label, serializer);
7991 <Option<String>>::sse_encode(self.message, serializer);
7992 }
7993}
7994
7995impl SseEncode for crate::model::LiquidNetwork {
7996 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7998 <i32>::sse_encode(
7999 match self {
8000 crate::model::LiquidNetwork::Mainnet => 0,
8001 crate::model::LiquidNetwork::Testnet => 1,
8002 crate::model::LiquidNetwork::Regtest => 2,
8003 _ => {
8004 unimplemented!("");
8005 }
8006 },
8007 serializer,
8008 );
8009 }
8010}
8011
8012impl SseEncode for Vec<String> {
8013 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8015 <i32>::sse_encode(self.len() as _, serializer);
8016 for item in self {
8017 <String>::sse_encode(item, serializer);
8018 }
8019 }
8020}
8021
8022impl SseEncode for Vec<crate::model::AssetBalance> {
8023 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8025 <i32>::sse_encode(self.len() as _, serializer);
8026 for item in self {
8027 <crate::model::AssetBalance>::sse_encode(item, serializer);
8028 }
8029 }
8030}
8031
8032impl SseEncode for Vec<crate::model::AssetMetadata> {
8033 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8035 <i32>::sse_encode(self.len() as _, serializer);
8036 for item in self {
8037 <crate::model::AssetMetadata>::sse_encode(item, serializer);
8038 }
8039 }
8040}
8041
8042impl SseEncode for Vec<crate::bindings::ExternalInputParser> {
8043 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8045 <i32>::sse_encode(self.len() as _, serializer);
8046 for item in self {
8047 <crate::bindings::ExternalInputParser>::sse_encode(item, serializer);
8048 }
8049 }
8050}
8051
8052impl SseEncode for Vec<crate::bindings::FiatCurrency> {
8053 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8055 <i32>::sse_encode(self.len() as _, serializer);
8056 for item in self {
8057 <crate::bindings::FiatCurrency>::sse_encode(item, serializer);
8058 }
8059 }
8060}
8061
8062impl SseEncode for Vec<crate::bindings::LnOfferBlindedPath> {
8063 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8065 <i32>::sse_encode(self.len() as _, serializer);
8066 for item in self {
8067 <crate::bindings::LnOfferBlindedPath>::sse_encode(item, serializer);
8068 }
8069 }
8070}
8071
8072impl SseEncode for Vec<crate::bindings::LocaleOverrides> {
8073 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8075 <i32>::sse_encode(self.len() as _, serializer);
8076 for item in self {
8077 <crate::bindings::LocaleOverrides>::sse_encode(item, serializer);
8078 }
8079 }
8080}
8081
8082impl SseEncode for Vec<crate::bindings::LocalizedName> {
8083 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8085 <i32>::sse_encode(self.len() as _, serializer);
8086 for item in self {
8087 <crate::bindings::LocalizedName>::sse_encode(item, serializer);
8088 }
8089 }
8090}
8091
8092impl SseEncode for Vec<crate::model::Payment> {
8093 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8095 <i32>::sse_encode(self.len() as _, serializer);
8096 for item in self {
8097 <crate::model::Payment>::sse_encode(item, serializer);
8098 }
8099 }
8100}
8101
8102impl SseEncode for crate::model::ListPaymentDetails {
8103 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8105 match self {
8106 crate::model::ListPaymentDetails::Liquid {
8107 asset_id,
8108 destination,
8109 } => {
8110 <i32>::sse_encode(0, serializer);
8111 <Option<String>>::sse_encode(asset_id, serializer);
8112 <Option<String>>::sse_encode(destination, serializer);
8113 }
8114 crate::model::ListPaymentDetails::Bitcoin { address } => {
8115 <i32>::sse_encode(1, serializer);
8116 <Option<String>>::sse_encode(address, serializer);
8117 }
8118 _ => {
8119 unimplemented!("");
8120 }
8121 }
8122 }
8123}
8124
8125impl SseEncode for Vec<crate::model::PaymentState> {
8126 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8128 <i32>::sse_encode(self.len() as _, serializer);
8129 for item in self {
8130 <crate::model::PaymentState>::sse_encode(item, serializer);
8131 }
8132 }
8133}
8134
8135impl SseEncode for Vec<crate::model::PaymentType> {
8136 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8138 <i32>::sse_encode(self.len() as _, serializer);
8139 for item in self {
8140 <crate::model::PaymentType>::sse_encode(item, serializer);
8141 }
8142 }
8143}
8144
8145impl SseEncode for crate::model::ListPaymentsRequest {
8146 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8148 <Option<Vec<crate::model::PaymentType>>>::sse_encode(self.filters, serializer);
8149 <Option<Vec<crate::model::PaymentState>>>::sse_encode(self.states, serializer);
8150 <Option<i64>>::sse_encode(self.from_timestamp, serializer);
8151 <Option<i64>>::sse_encode(self.to_timestamp, serializer);
8152 <Option<u32>>::sse_encode(self.offset, serializer);
8153 <Option<u32>>::sse_encode(self.limit, serializer);
8154 <Option<crate::model::ListPaymentDetails>>::sse_encode(self.details, serializer);
8155 <Option<bool>>::sse_encode(self.sort_ascending, serializer);
8156 }
8157}
8158
8159impl SseEncode for Vec<u8> {
8160 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8162 <i32>::sse_encode(self.len() as _, serializer);
8163 for item in self {
8164 <u8>::sse_encode(item, serializer);
8165 }
8166 }
8167}
8168
8169impl SseEncode for Vec<crate::bindings::Rate> {
8170 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8172 <i32>::sse_encode(self.len() as _, serializer);
8173 for item in self {
8174 <crate::bindings::Rate>::sse_encode(item, serializer);
8175 }
8176 }
8177}
8178
8179impl SseEncode for Vec<crate::model::RefundableSwap> {
8180 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8182 <i32>::sse_encode(self.len() as _, serializer);
8183 for item in self {
8184 <crate::model::RefundableSwap>::sse_encode(item, serializer);
8185 }
8186 }
8187}
8188
8189impl SseEncode for Vec<crate::bindings::RouteHint> {
8190 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8192 <i32>::sse_encode(self.len() as _, serializer);
8193 for item in self {
8194 <crate::bindings::RouteHint>::sse_encode(item, serializer);
8195 }
8196 }
8197}
8198
8199impl SseEncode for Vec<crate::bindings::RouteHintHop> {
8200 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8202 <i32>::sse_encode(self.len() as _, serializer);
8203 for item in self {
8204 <crate::bindings::RouteHintHop>::sse_encode(item, serializer);
8205 }
8206 }
8207}
8208
8209impl SseEncode for crate::bindings::LNInvoice {
8210 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8212 <String>::sse_encode(self.bolt11, serializer);
8213 <crate::bindings::Network>::sse_encode(self.network, serializer);
8214 <String>::sse_encode(self.payee_pubkey, serializer);
8215 <String>::sse_encode(self.payment_hash, serializer);
8216 <Option<String>>::sse_encode(self.description, serializer);
8217 <Option<String>>::sse_encode(self.description_hash, serializer);
8218 <Option<u64>>::sse_encode(self.amount_msat, serializer);
8219 <u64>::sse_encode(self.timestamp, serializer);
8220 <u64>::sse_encode(self.expiry, serializer);
8221 <Vec<crate::bindings::RouteHint>>::sse_encode(self.routing_hints, serializer);
8222 <Vec<u8>>::sse_encode(self.payment_secret, serializer);
8223 <u64>::sse_encode(self.min_final_cltv_expiry_delta, serializer);
8224 }
8225}
8226
8227impl SseEncode for crate::bindings::LNOffer {
8228 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8230 <String>::sse_encode(self.offer, serializer);
8231 <Vec<String>>::sse_encode(self.chains, serializer);
8232 <Option<crate::bindings::Amount>>::sse_encode(self.min_amount, serializer);
8233 <Option<String>>::sse_encode(self.description, serializer);
8234 <Option<u64>>::sse_encode(self.absolute_expiry, serializer);
8235 <Option<String>>::sse_encode(self.issuer, serializer);
8236 <Option<String>>::sse_encode(self.signing_pubkey, serializer);
8237 <Vec<crate::bindings::LnOfferBlindedPath>>::sse_encode(self.paths, serializer);
8238 }
8239}
8240
8241impl SseEncode for crate::bindings::LnOfferBlindedPath {
8242 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8244 <Vec<String>>::sse_encode(self.blinded_hops, serializer);
8245 }
8246}
8247
8248impl SseEncode for crate::bindings::duplicates::LnUrlAuthError {
8249 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8251 match self {
8252 crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
8253 <i32>::sse_encode(0, serializer);
8254 <String>::sse_encode(err, serializer);
8255 }
8256 crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
8257 <i32>::sse_encode(1, serializer);
8258 <String>::sse_encode(err, serializer);
8259 }
8260 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
8261 <i32>::sse_encode(2, serializer);
8262 <String>::sse_encode(err, serializer);
8263 }
8264 _ => {
8265 unimplemented!("");
8266 }
8267 }
8268 }
8269}
8270
8271impl SseEncode for crate::bindings::LnUrlAuthRequestData {
8272 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8274 <String>::sse_encode(self.k1, serializer);
8275 <Option<String>>::sse_encode(self.action, serializer);
8276 <String>::sse_encode(self.domain, serializer);
8277 <String>::sse_encode(self.url, serializer);
8278 }
8279}
8280
8281impl SseEncode for crate::bindings::duplicates::LnUrlCallbackStatus {
8282 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8284 match self {
8285 crate::bindings::duplicates::LnUrlCallbackStatus::Ok => {
8286 <i32>::sse_encode(0, serializer);
8287 }
8288 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
8289 <i32>::sse_encode(1, serializer);
8290 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8291 }
8292 _ => {
8293 unimplemented!("");
8294 }
8295 }
8296 }
8297}
8298
8299impl SseEncode for crate::bindings::LnUrlErrorData {
8300 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8302 <String>::sse_encode(self.reason, serializer);
8303 }
8304}
8305
8306impl SseEncode for crate::model::LnUrlInfo {
8307 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8309 <Option<String>>::sse_encode(self.ln_address, serializer);
8310 <Option<String>>::sse_encode(self.lnurl_pay_comment, serializer);
8311 <Option<String>>::sse_encode(self.lnurl_pay_domain, serializer);
8312 <Option<String>>::sse_encode(self.lnurl_pay_metadata, serializer);
8313 <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8314 self.lnurl_pay_success_action,
8315 serializer,
8316 );
8317 <Option<crate::bindings::SuccessAction>>::sse_encode(
8318 self.lnurl_pay_unprocessed_success_action,
8319 serializer,
8320 );
8321 <Option<String>>::sse_encode(self.lnurl_withdraw_endpoint, serializer);
8322 }
8323}
8324
8325impl SseEncode for crate::bindings::duplicates::LnUrlPayError {
8326 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8328 match self {
8329 crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => {
8330 <i32>::sse_encode(0, serializer);
8331 }
8332 crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
8333 <i32>::sse_encode(1, serializer);
8334 <String>::sse_encode(err, serializer);
8335 }
8336 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
8337 <i32>::sse_encode(2, serializer);
8338 <String>::sse_encode(err, serializer);
8339 }
8340 crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
8341 <i32>::sse_encode(3, serializer);
8342 <String>::sse_encode(err, serializer);
8343 }
8344 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
8345 <i32>::sse_encode(4, serializer);
8346 <String>::sse_encode(err, serializer);
8347 }
8348 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
8349 <i32>::sse_encode(5, serializer);
8350 <String>::sse_encode(err, serializer);
8351 }
8352 crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
8353 <i32>::sse_encode(6, serializer);
8354 <String>::sse_encode(err, serializer);
8355 }
8356 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
8357 <i32>::sse_encode(7, serializer);
8358 <String>::sse_encode(err, serializer);
8359 }
8360 crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
8361 <i32>::sse_encode(8, serializer);
8362 <String>::sse_encode(err, serializer);
8363 }
8364 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
8365 <i32>::sse_encode(9, serializer);
8366 <String>::sse_encode(err, serializer);
8367 }
8368 crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
8369 <i32>::sse_encode(10, serializer);
8370 <String>::sse_encode(err, serializer);
8371 }
8372 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
8373 <i32>::sse_encode(11, serializer);
8374 <String>::sse_encode(err, serializer);
8375 }
8376 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
8377 <i32>::sse_encode(12, serializer);
8378 <String>::sse_encode(err, serializer);
8379 }
8380 _ => {
8381 unimplemented!("");
8382 }
8383 }
8384 }
8385}
8386
8387impl SseEncode for crate::bindings::LnUrlPayErrorData {
8388 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8390 <String>::sse_encode(self.payment_hash, serializer);
8391 <String>::sse_encode(self.reason, serializer);
8392 }
8393}
8394
8395impl SseEncode for crate::model::LnUrlPayRequest {
8396 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8398 <crate::model::PrepareLnUrlPayResponse>::sse_encode(self.prepare_response, serializer);
8399 }
8400}
8401
8402impl SseEncode for crate::bindings::LnUrlPayRequestData {
8403 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8405 <String>::sse_encode(self.callback, serializer);
8406 <u64>::sse_encode(self.min_sendable, serializer);
8407 <u64>::sse_encode(self.max_sendable, serializer);
8408 <String>::sse_encode(self.metadata_str, serializer);
8409 <u16>::sse_encode(self.comment_allowed, serializer);
8410 <String>::sse_encode(self.domain, serializer);
8411 <bool>::sse_encode(self.allows_nostr, serializer);
8412 <Option<String>>::sse_encode(self.nostr_pubkey, serializer);
8413 <Option<String>>::sse_encode(self.ln_address, serializer);
8414 }
8415}
8416
8417impl SseEncode for crate::model::LnUrlPayResult {
8418 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8420 match self {
8421 crate::model::LnUrlPayResult::EndpointSuccess { data } => {
8422 <i32>::sse_encode(0, serializer);
8423 <crate::model::LnUrlPaySuccessData>::sse_encode(data, serializer);
8424 }
8425 crate::model::LnUrlPayResult::EndpointError { data } => {
8426 <i32>::sse_encode(1, serializer);
8427 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8428 }
8429 crate::model::LnUrlPayResult::PayError { data } => {
8430 <i32>::sse_encode(2, serializer);
8431 <crate::bindings::LnUrlPayErrorData>::sse_encode(data, serializer);
8432 }
8433 _ => {
8434 unimplemented!("");
8435 }
8436 }
8437 }
8438}
8439
8440impl SseEncode for crate::model::LnUrlPaySuccessData {
8441 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8443 <crate::model::Payment>::sse_encode(self.payment, serializer);
8444 <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8445 self.success_action,
8446 serializer,
8447 );
8448 }
8449}
8450
8451impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawError {
8452 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8454 match self {
8455 crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
8456 <i32>::sse_encode(0, serializer);
8457 <String>::sse_encode(err, serializer);
8458 }
8459 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
8460 <i32>::sse_encode(1, serializer);
8461 <String>::sse_encode(err, serializer);
8462 }
8463 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
8464 <i32>::sse_encode(2, serializer);
8465 <String>::sse_encode(err, serializer);
8466 }
8467 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
8468 <i32>::sse_encode(3, serializer);
8469 <String>::sse_encode(err, serializer);
8470 }
8471 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
8472 <i32>::sse_encode(4, serializer);
8473 <String>::sse_encode(err, serializer);
8474 }
8475 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
8476 <i32>::sse_encode(5, serializer);
8477 <String>::sse_encode(err, serializer);
8478 }
8479 _ => {
8480 unimplemented!("");
8481 }
8482 }
8483 }
8484}
8485
8486impl SseEncode for crate::bindings::LnUrlWithdrawRequest {
8487 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8489 <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(self.data, serializer);
8490 <u64>::sse_encode(self.amount_msat, serializer);
8491 <Option<String>>::sse_encode(self.description, serializer);
8492 }
8493}
8494
8495impl SseEncode for crate::bindings::LnUrlWithdrawRequestData {
8496 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8498 <String>::sse_encode(self.callback, serializer);
8499 <String>::sse_encode(self.k1, serializer);
8500 <String>::sse_encode(self.default_description, serializer);
8501 <u64>::sse_encode(self.min_withdrawable, serializer);
8502 <u64>::sse_encode(self.max_withdrawable, serializer);
8503 }
8504}
8505
8506impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawResult {
8507 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8509 match self {
8510 crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
8511 <i32>::sse_encode(0, serializer);
8512 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8513 data, serializer,
8514 );
8515 }
8516 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
8517 <i32>::sse_encode(1, serializer);
8518 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8519 data, serializer,
8520 );
8521 }
8522 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
8523 <i32>::sse_encode(2, serializer);
8524 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8525 }
8526 _ => {
8527 unimplemented!("");
8528 }
8529 }
8530 }
8531}
8532
8533impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
8534 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8536 <crate::bindings::LNInvoice>::sse_encode(self.invoice, serializer);
8537 }
8538}
8539
8540impl SseEncode for crate::bindings::LocaleOverrides {
8541 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8543 <String>::sse_encode(self.locale, serializer);
8544 <Option<u32>>::sse_encode(self.spacing, serializer);
8545 <crate::bindings::Symbol>::sse_encode(self.symbol, serializer);
8546 }
8547}
8548
8549impl SseEncode for crate::bindings::LocalizedName {
8550 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8552 <String>::sse_encode(self.locale, serializer);
8553 <String>::sse_encode(self.name, serializer);
8554 }
8555}
8556
8557impl SseEncode for crate::model::LogEntry {
8558 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8560 <String>::sse_encode(self.line, serializer);
8561 <String>::sse_encode(self.level, serializer);
8562 }
8563}
8564
8565impl SseEncode for crate::bindings::MessageSuccessActionData {
8566 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8568 <String>::sse_encode(self.message, serializer);
8569 }
8570}
8571
8572impl SseEncode for crate::bindings::Network {
8573 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8575 <i32>::sse_encode(
8576 match self {
8577 crate::bindings::Network::Bitcoin => 0,
8578 crate::bindings::Network::Testnet => 1,
8579 crate::bindings::Network::Signet => 2,
8580 crate::bindings::Network::Regtest => 3,
8581 _ => {
8582 unimplemented!("");
8583 }
8584 },
8585 serializer,
8586 );
8587 }
8588}
8589
8590impl SseEncode for crate::model::OnchainPaymentLimitsResponse {
8591 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8593 <crate::model::Limits>::sse_encode(self.send, serializer);
8594 <crate::model::Limits>::sse_encode(self.receive, serializer);
8595 }
8596}
8597
8598impl SseEncode for Option<String> {
8599 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8601 <bool>::sse_encode(self.is_some(), serializer);
8602 if let Some(value) = self {
8603 <String>::sse_encode(value, serializer);
8604 }
8605 }
8606}
8607
8608impl SseEncode for Option<crate::bindings::Amount> {
8609 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8611 <bool>::sse_encode(self.is_some(), serializer);
8612 if let Some(value) = self {
8613 <crate::bindings::Amount>::sse_encode(value, serializer);
8614 }
8615 }
8616}
8617
8618impl SseEncode for Option<crate::model::AssetInfo> {
8619 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8621 <bool>::sse_encode(self.is_some(), serializer);
8622 if let Some(value) = self {
8623 <crate::model::AssetInfo>::sse_encode(value, serializer);
8624 }
8625 }
8626}
8627
8628impl SseEncode for Option<bool> {
8629 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8631 <bool>::sse_encode(self.is_some(), serializer);
8632 if let Some(value) = self {
8633 <bool>::sse_encode(value, serializer);
8634 }
8635 }
8636}
8637
8638impl SseEncode for Option<f64> {
8639 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8641 <bool>::sse_encode(self.is_some(), serializer);
8642 if let Some(value) = self {
8643 <f64>::sse_encode(value, serializer);
8644 }
8645 }
8646}
8647
8648impl SseEncode for Option<i64> {
8649 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8651 <bool>::sse_encode(self.is_some(), serializer);
8652 if let Some(value) = self {
8653 <i64>::sse_encode(value, serializer);
8654 }
8655 }
8656}
8657
8658impl SseEncode for Option<crate::model::ListPaymentDetails> {
8659 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8661 <bool>::sse_encode(self.is_some(), serializer);
8662 if let Some(value) = self {
8663 <crate::model::ListPaymentDetails>::sse_encode(value, serializer);
8664 }
8665 }
8666}
8667
8668impl SseEncode for Option<crate::model::LnUrlInfo> {
8669 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8671 <bool>::sse_encode(self.is_some(), serializer);
8672 if let Some(value) = self {
8673 <crate::model::LnUrlInfo>::sse_encode(value, serializer);
8674 }
8675 }
8676}
8677
8678impl SseEncode for Option<crate::model::PayAmount> {
8679 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8681 <bool>::sse_encode(self.is_some(), serializer);
8682 if let Some(value) = self {
8683 <crate::model::PayAmount>::sse_encode(value, serializer);
8684 }
8685 }
8686}
8687
8688impl SseEncode for Option<crate::model::Payment> {
8689 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8691 <bool>::sse_encode(self.is_some(), serializer);
8692 if let Some(value) = self {
8693 <crate::model::Payment>::sse_encode(value, serializer);
8694 }
8695 }
8696}
8697
8698impl SseEncode for Option<crate::model::ReceiveAmount> {
8699 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8701 <bool>::sse_encode(self.is_some(), serializer);
8702 if let Some(value) = self {
8703 <crate::model::ReceiveAmount>::sse_encode(value, serializer);
8704 }
8705 }
8706}
8707
8708impl SseEncode for Option<crate::bindings::SuccessAction> {
8709 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8711 <bool>::sse_encode(self.is_some(), serializer);
8712 if let Some(value) = self {
8713 <crate::bindings::SuccessAction>::sse_encode(value, serializer);
8714 }
8715 }
8716}
8717
8718impl SseEncode for Option<crate::bindings::SuccessActionProcessed> {
8719 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8721 <bool>::sse_encode(self.is_some(), serializer);
8722 if let Some(value) = self {
8723 <crate::bindings::SuccessActionProcessed>::sse_encode(value, serializer);
8724 }
8725 }
8726}
8727
8728impl SseEncode for Option<crate::bindings::Symbol> {
8729 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8731 <bool>::sse_encode(self.is_some(), serializer);
8732 if let Some(value) = self {
8733 <crate::bindings::Symbol>::sse_encode(value, serializer);
8734 }
8735 }
8736}
8737
8738impl SseEncode for Option<u32> {
8739 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8741 <bool>::sse_encode(self.is_some(), serializer);
8742 if let Some(value) = self {
8743 <u32>::sse_encode(value, serializer);
8744 }
8745 }
8746}
8747
8748impl SseEncode for Option<u64> {
8749 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8751 <bool>::sse_encode(self.is_some(), serializer);
8752 if let Some(value) = self {
8753 <u64>::sse_encode(value, serializer);
8754 }
8755 }
8756}
8757
8758impl SseEncode for Option<Vec<crate::model::AssetMetadata>> {
8759 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8761 <bool>::sse_encode(self.is_some(), serializer);
8762 if let Some(value) = self {
8763 <Vec<crate::model::AssetMetadata>>::sse_encode(value, serializer);
8764 }
8765 }
8766}
8767
8768impl SseEncode for Option<Vec<crate::bindings::ExternalInputParser>> {
8769 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8771 <bool>::sse_encode(self.is_some(), serializer);
8772 if let Some(value) = self {
8773 <Vec<crate::bindings::ExternalInputParser>>::sse_encode(value, serializer);
8774 }
8775 }
8776}
8777
8778impl SseEncode for Option<Vec<crate::model::PaymentState>> {
8779 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8781 <bool>::sse_encode(self.is_some(), serializer);
8782 if let Some(value) = self {
8783 <Vec<crate::model::PaymentState>>::sse_encode(value, serializer);
8784 }
8785 }
8786}
8787
8788impl SseEncode for Option<Vec<crate::model::PaymentType>> {
8789 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8791 <bool>::sse_encode(self.is_some(), serializer);
8792 if let Some(value) = self {
8793 <Vec<crate::model::PaymentType>>::sse_encode(value, serializer);
8794 }
8795 }
8796}
8797
8798impl SseEncode for Option<Vec<u8>> {
8799 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8801 <bool>::sse_encode(self.is_some(), serializer);
8802 if let Some(value) = self {
8803 <Vec<u8>>::sse_encode(value, serializer);
8804 }
8805 }
8806}
8807
8808impl SseEncode for crate::model::PayAmount {
8809 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8811 match self {
8812 crate::model::PayAmount::Bitcoin {
8813 receiver_amount_sat,
8814 } => {
8815 <i32>::sse_encode(0, serializer);
8816 <u64>::sse_encode(receiver_amount_sat, serializer);
8817 }
8818 crate::model::PayAmount::Asset {
8819 to_asset,
8820 receiver_amount,
8821 estimate_asset_fees,
8822 from_asset,
8823 } => {
8824 <i32>::sse_encode(1, serializer);
8825 <String>::sse_encode(to_asset, serializer);
8826 <f64>::sse_encode(receiver_amount, serializer);
8827 <Option<bool>>::sse_encode(estimate_asset_fees, serializer);
8828 <Option<String>>::sse_encode(from_asset, serializer);
8829 }
8830 crate::model::PayAmount::Drain => {
8831 <i32>::sse_encode(2, serializer);
8832 }
8833 _ => {
8834 unimplemented!("");
8835 }
8836 }
8837 }
8838}
8839
8840impl SseEncode for crate::model::PayOnchainRequest {
8841 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8843 <String>::sse_encode(self.address, serializer);
8844 <crate::model::PreparePayOnchainResponse>::sse_encode(self.prepare_response, serializer);
8845 }
8846}
8847
8848impl SseEncode for crate::model::Payment {
8849 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8851 <Option<String>>::sse_encode(self.destination, serializer);
8852 <Option<String>>::sse_encode(self.tx_id, serializer);
8853 <Option<String>>::sse_encode(self.unblinding_data, serializer);
8854 <u32>::sse_encode(self.timestamp, serializer);
8855 <u64>::sse_encode(self.amount_sat, serializer);
8856 <u64>::sse_encode(self.fees_sat, serializer);
8857 <Option<u64>>::sse_encode(self.swapper_fees_sat, serializer);
8858 <crate::model::PaymentType>::sse_encode(self.payment_type, serializer);
8859 <crate::model::PaymentState>::sse_encode(self.status, serializer);
8860 <crate::model::PaymentDetails>::sse_encode(self.details, serializer);
8861 }
8862}
8863
8864impl SseEncode for crate::model::PaymentDetails {
8865 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8867 match self {
8868 crate::model::PaymentDetails::Lightning {
8869 swap_id,
8870 description,
8871 liquid_expiration_blockheight,
8872 preimage,
8873 invoice,
8874 bolt12_offer,
8875 payment_hash,
8876 destination_pubkey,
8877 lnurl_info,
8878 bip353_address,
8879 payer_note,
8880 claim_tx_id,
8881 refund_tx_id,
8882 refund_tx_amount_sat,
8883 } => {
8884 <i32>::sse_encode(0, serializer);
8885 <String>::sse_encode(swap_id, serializer);
8886 <String>::sse_encode(description, serializer);
8887 <u32>::sse_encode(liquid_expiration_blockheight, serializer);
8888 <Option<String>>::sse_encode(preimage, serializer);
8889 <Option<String>>::sse_encode(invoice, serializer);
8890 <Option<String>>::sse_encode(bolt12_offer, serializer);
8891 <Option<String>>::sse_encode(payment_hash, serializer);
8892 <Option<String>>::sse_encode(destination_pubkey, serializer);
8893 <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8894 <Option<String>>::sse_encode(bip353_address, serializer);
8895 <Option<String>>::sse_encode(payer_note, serializer);
8896 <Option<String>>::sse_encode(claim_tx_id, serializer);
8897 <Option<String>>::sse_encode(refund_tx_id, serializer);
8898 <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8899 }
8900 crate::model::PaymentDetails::Liquid {
8901 destination,
8902 description,
8903 asset_id,
8904 asset_info,
8905 lnurl_info,
8906 bip353_address,
8907 payer_note,
8908 } => {
8909 <i32>::sse_encode(1, serializer);
8910 <String>::sse_encode(destination, serializer);
8911 <String>::sse_encode(description, serializer);
8912 <String>::sse_encode(asset_id, serializer);
8913 <Option<crate::model::AssetInfo>>::sse_encode(asset_info, serializer);
8914 <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8915 <Option<String>>::sse_encode(bip353_address, serializer);
8916 <Option<String>>::sse_encode(payer_note, serializer);
8917 }
8918 crate::model::PaymentDetails::Bitcoin {
8919 swap_id,
8920 bitcoin_address,
8921 description,
8922 auto_accepted_fees,
8923 liquid_expiration_blockheight,
8924 bitcoin_expiration_blockheight,
8925 lockup_tx_id,
8926 claim_tx_id,
8927 refund_tx_id,
8928 refund_tx_amount_sat,
8929 } => {
8930 <i32>::sse_encode(2, serializer);
8931 <String>::sse_encode(swap_id, serializer);
8932 <String>::sse_encode(bitcoin_address, serializer);
8933 <String>::sse_encode(description, serializer);
8934 <bool>::sse_encode(auto_accepted_fees, serializer);
8935 <Option<u32>>::sse_encode(liquid_expiration_blockheight, serializer);
8936 <Option<u32>>::sse_encode(bitcoin_expiration_blockheight, serializer);
8937 <Option<String>>::sse_encode(lockup_tx_id, serializer);
8938 <Option<String>>::sse_encode(claim_tx_id, serializer);
8939 <Option<String>>::sse_encode(refund_tx_id, serializer);
8940 <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8941 }
8942 _ => {
8943 unimplemented!("");
8944 }
8945 }
8946 }
8947}
8948
8949impl SseEncode for crate::error::PaymentError {
8950 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8952 match self {
8953 crate::error::PaymentError::AlreadyClaimed => {
8954 <i32>::sse_encode(0, serializer);
8955 }
8956 crate::error::PaymentError::AlreadyPaid => {
8957 <i32>::sse_encode(1, serializer);
8958 }
8959 crate::error::PaymentError::PaymentInProgress => {
8960 <i32>::sse_encode(2, serializer);
8961 }
8962 crate::error::PaymentError::AmountOutOfRange { min, max } => {
8963 <i32>::sse_encode(3, serializer);
8964 <u64>::sse_encode(min, serializer);
8965 <u64>::sse_encode(max, serializer);
8966 }
8967 crate::error::PaymentError::AmountMissing { err } => {
8968 <i32>::sse_encode(4, serializer);
8969 <String>::sse_encode(err, serializer);
8970 }
8971 crate::error::PaymentError::AssetError { err } => {
8972 <i32>::sse_encode(5, serializer);
8973 <String>::sse_encode(err, serializer);
8974 }
8975 crate::error::PaymentError::InvalidNetwork { err } => {
8976 <i32>::sse_encode(6, serializer);
8977 <String>::sse_encode(err, serializer);
8978 }
8979 crate::error::PaymentError::Generic { err } => {
8980 <i32>::sse_encode(7, serializer);
8981 <String>::sse_encode(err, serializer);
8982 }
8983 crate::error::PaymentError::InvalidOrExpiredFees => {
8984 <i32>::sse_encode(8, serializer);
8985 }
8986 crate::error::PaymentError::InsufficientFunds => {
8987 <i32>::sse_encode(9, serializer);
8988 }
8989 crate::error::PaymentError::InvalidDescription { err } => {
8990 <i32>::sse_encode(10, serializer);
8991 <String>::sse_encode(err, serializer);
8992 }
8993 crate::error::PaymentError::InvalidInvoice { err } => {
8994 <i32>::sse_encode(11, serializer);
8995 <String>::sse_encode(err, serializer);
8996 }
8997 crate::error::PaymentError::InvalidPreimage => {
8998 <i32>::sse_encode(12, serializer);
8999 }
9000 crate::error::PaymentError::PairsNotFound => {
9001 <i32>::sse_encode(13, serializer);
9002 }
9003 crate::error::PaymentError::PaymentTimeout => {
9004 <i32>::sse_encode(14, serializer);
9005 }
9006 crate::error::PaymentError::PersistError => {
9007 <i32>::sse_encode(15, serializer);
9008 }
9009 crate::error::PaymentError::ReceiveError { err } => {
9010 <i32>::sse_encode(16, serializer);
9011 <String>::sse_encode(err, serializer);
9012 }
9013 crate::error::PaymentError::Refunded { err, refund_tx_id } => {
9014 <i32>::sse_encode(17, serializer);
9015 <String>::sse_encode(err, serializer);
9016 <String>::sse_encode(refund_tx_id, serializer);
9017 }
9018 crate::error::PaymentError::SelfTransferNotSupported => {
9019 <i32>::sse_encode(18, serializer);
9020 }
9021 crate::error::PaymentError::SendError { err } => {
9022 <i32>::sse_encode(19, serializer);
9023 <String>::sse_encode(err, serializer);
9024 }
9025 crate::error::PaymentError::SignerError { err } => {
9026 <i32>::sse_encode(20, serializer);
9027 <String>::sse_encode(err, serializer);
9028 }
9029 _ => {
9030 unimplemented!("");
9031 }
9032 }
9033 }
9034}
9035
9036impl SseEncode for crate::model::PaymentMethod {
9037 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9039 <i32>::sse_encode(
9040 match self {
9041 crate::model::PaymentMethod::Lightning => 0,
9042 crate::model::PaymentMethod::Bolt11Invoice => 1,
9043 crate::model::PaymentMethod::Bolt12Offer => 2,
9044 crate::model::PaymentMethod::BitcoinAddress => 3,
9045 crate::model::PaymentMethod::LiquidAddress => 4,
9046 _ => {
9047 unimplemented!("");
9048 }
9049 },
9050 serializer,
9051 );
9052 }
9053}
9054
9055impl SseEncode for crate::model::PaymentState {
9056 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9058 <i32>::sse_encode(
9059 match self {
9060 crate::model::PaymentState::Created => 0,
9061 crate::model::PaymentState::Pending => 1,
9062 crate::model::PaymentState::Complete => 2,
9063 crate::model::PaymentState::Failed => 3,
9064 crate::model::PaymentState::TimedOut => 4,
9065 crate::model::PaymentState::Refundable => 5,
9066 crate::model::PaymentState::RefundPending => 6,
9067 crate::model::PaymentState::WaitingFeeAcceptance => 7,
9068 _ => {
9069 unimplemented!("");
9070 }
9071 },
9072 serializer,
9073 );
9074 }
9075}
9076
9077impl SseEncode for crate::model::PaymentType {
9078 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9080 <i32>::sse_encode(
9081 match self {
9082 crate::model::PaymentType::Receive => 0,
9083 crate::model::PaymentType::Send => 1,
9084 _ => {
9085 unimplemented!("");
9086 }
9087 },
9088 serializer,
9089 );
9090 }
9091}
9092
9093impl SseEncode for crate::model::PrepareBuyBitcoinRequest {
9094 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9096 <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9097 <u64>::sse_encode(self.amount_sat, serializer);
9098 }
9099}
9100
9101impl SseEncode for crate::model::PrepareBuyBitcoinResponse {
9102 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9104 <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9105 <u64>::sse_encode(self.amount_sat, serializer);
9106 <u64>::sse_encode(self.fees_sat, serializer);
9107 }
9108}
9109
9110impl SseEncode for crate::model::PrepareLnUrlPayRequest {
9111 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9113 <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9114 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9115 <Option<String>>::sse_encode(self.bip353_address, serializer);
9116 <Option<String>>::sse_encode(self.comment, serializer);
9117 <Option<bool>>::sse_encode(self.validate_success_action_url, serializer);
9118 }
9119}
9120
9121impl SseEncode for crate::model::PrepareLnUrlPayResponse {
9122 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9124 <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9125 <u64>::sse_encode(self.fees_sat, serializer);
9126 <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9127 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9128 <Option<String>>::sse_encode(self.comment, serializer);
9129 <Option<crate::bindings::SuccessAction>>::sse_encode(self.success_action, serializer);
9130 }
9131}
9132
9133impl SseEncode for crate::model::PreparePayOnchainRequest {
9134 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9136 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9137 <Option<u32>>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9138 }
9139}
9140
9141impl SseEncode for crate::model::PreparePayOnchainResponse {
9142 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9144 <u64>::sse_encode(self.receiver_amount_sat, serializer);
9145 <u64>::sse_encode(self.claim_fees_sat, serializer);
9146 <u64>::sse_encode(self.total_fees_sat, serializer);
9147 }
9148}
9149
9150impl SseEncode for crate::model::PrepareReceiveRequest {
9151 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9153 <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9154 <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9155 }
9156}
9157
9158impl SseEncode for crate::model::PrepareReceiveResponse {
9159 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9161 <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9162 <u64>::sse_encode(self.fees_sat, serializer);
9163 <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9164 <Option<u64>>::sse_encode(self.min_payer_amount_sat, serializer);
9165 <Option<u64>>::sse_encode(self.max_payer_amount_sat, serializer);
9166 <Option<f64>>::sse_encode(self.swapper_feerate, serializer);
9167 }
9168}
9169
9170impl SseEncode for crate::model::PrepareRefundRequest {
9171 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9173 <String>::sse_encode(self.swap_address, serializer);
9174 <String>::sse_encode(self.refund_address, serializer);
9175 <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9176 }
9177}
9178
9179impl SseEncode for crate::model::PrepareRefundResponse {
9180 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9182 <u32>::sse_encode(self.tx_vsize, serializer);
9183 <u64>::sse_encode(self.tx_fee_sat, serializer);
9184 <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9185 }
9186}
9187
9188impl SseEncode for crate::model::PrepareSendRequest {
9189 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9191 <String>::sse_encode(self.destination, serializer);
9192 <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9193 }
9194}
9195
9196impl SseEncode for crate::model::PrepareSendResponse {
9197 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9199 <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9200 <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9201 <Option<u64>>::sse_encode(self.fees_sat, serializer);
9202 <Option<f64>>::sse_encode(self.estimated_asset_fees, serializer);
9203 <Option<u64>>::sse_encode(self.exchange_amount_sat, serializer);
9204 }
9205}
9206
9207impl SseEncode for crate::bindings::Rate {
9208 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9210 <String>::sse_encode(self.coin, serializer);
9211 <f64>::sse_encode(self.value, serializer);
9212 }
9213}
9214
9215impl SseEncode for crate::model::ReceiveAmount {
9216 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9218 match self {
9219 crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
9220 <i32>::sse_encode(0, serializer);
9221 <u64>::sse_encode(payer_amount_sat, serializer);
9222 }
9223 crate::model::ReceiveAmount::Asset {
9224 asset_id,
9225 payer_amount,
9226 } => {
9227 <i32>::sse_encode(1, serializer);
9228 <String>::sse_encode(asset_id, serializer);
9229 <Option<f64>>::sse_encode(payer_amount, serializer);
9230 }
9231 _ => {
9232 unimplemented!("");
9233 }
9234 }
9235 }
9236}
9237
9238impl SseEncode for crate::model::ReceivePaymentRequest {
9239 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9241 <crate::model::PrepareReceiveResponse>::sse_encode(self.prepare_response, serializer);
9242 <Option<String>>::sse_encode(self.description, serializer);
9243 <Option<bool>>::sse_encode(self.use_description_hash, serializer);
9244 <Option<String>>::sse_encode(self.payer_note, serializer);
9245 }
9246}
9247
9248impl SseEncode for crate::model::ReceivePaymentResponse {
9249 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9251 <String>::sse_encode(self.destination, serializer);
9252 }
9253}
9254
9255impl SseEncode for crate::model::RecommendedFees {
9256 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9258 <u64>::sse_encode(self.fastest_fee, serializer);
9259 <u64>::sse_encode(self.half_hour_fee, serializer);
9260 <u64>::sse_encode(self.hour_fee, serializer);
9261 <u64>::sse_encode(self.economy_fee, serializer);
9262 <u64>::sse_encode(self.minimum_fee, serializer);
9263 }
9264}
9265
9266impl SseEncode for crate::model::RefundRequest {
9267 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9269 <String>::sse_encode(self.swap_address, serializer);
9270 <String>::sse_encode(self.refund_address, serializer);
9271 <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9272 }
9273}
9274
9275impl SseEncode for crate::model::RefundResponse {
9276 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9278 <String>::sse_encode(self.refund_tx_id, serializer);
9279 }
9280}
9281
9282impl SseEncode for crate::model::RefundableSwap {
9283 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9285 <String>::sse_encode(self.swap_address, serializer);
9286 <u32>::sse_encode(self.timestamp, serializer);
9287 <u64>::sse_encode(self.amount_sat, serializer);
9288 <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9289 }
9290}
9291
9292impl SseEncode for crate::model::RestoreRequest {
9293 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9295 <Option<String>>::sse_encode(self.backup_path, serializer);
9296 }
9297}
9298
9299impl SseEncode for crate::bindings::RouteHint {
9300 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9302 <Vec<crate::bindings::RouteHintHop>>::sse_encode(self.hops, serializer);
9303 }
9304}
9305
9306impl SseEncode for crate::bindings::RouteHintHop {
9307 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9309 <String>::sse_encode(self.src_node_id, serializer);
9310 <String>::sse_encode(self.short_channel_id, serializer);
9311 <u32>::sse_encode(self.fees_base_msat, serializer);
9312 <u32>::sse_encode(self.fees_proportional_millionths, serializer);
9313 <u64>::sse_encode(self.cltv_expiry_delta, serializer);
9314 <Option<u64>>::sse_encode(self.htlc_minimum_msat, serializer);
9315 <Option<u64>>::sse_encode(self.htlc_maximum_msat, serializer);
9316 }
9317}
9318
9319impl SseEncode for crate::error::SdkError {
9320 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9322 match self {
9323 crate::error::SdkError::AlreadyStarted => {
9324 <i32>::sse_encode(0, serializer);
9325 }
9326 crate::error::SdkError::Generic { err } => {
9327 <i32>::sse_encode(1, serializer);
9328 <String>::sse_encode(err, serializer);
9329 }
9330 crate::error::SdkError::NotStarted => {
9331 <i32>::sse_encode(2, serializer);
9332 }
9333 crate::error::SdkError::ServiceConnectivity { err } => {
9334 <i32>::sse_encode(3, serializer);
9335 <String>::sse_encode(err, serializer);
9336 }
9337 _ => {
9338 unimplemented!("");
9339 }
9340 }
9341 }
9342}
9343
9344impl SseEncode for crate::model::SdkEvent {
9345 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9347 match self {
9348 crate::model::SdkEvent::PaymentFailed { details } => {
9349 <i32>::sse_encode(0, serializer);
9350 <crate::model::Payment>::sse_encode(details, serializer);
9351 }
9352 crate::model::SdkEvent::PaymentPending { details } => {
9353 <i32>::sse_encode(1, serializer);
9354 <crate::model::Payment>::sse_encode(details, serializer);
9355 }
9356 crate::model::SdkEvent::PaymentRefundable { details } => {
9357 <i32>::sse_encode(2, serializer);
9358 <crate::model::Payment>::sse_encode(details, serializer);
9359 }
9360 crate::model::SdkEvent::PaymentRefunded { details } => {
9361 <i32>::sse_encode(3, serializer);
9362 <crate::model::Payment>::sse_encode(details, serializer);
9363 }
9364 crate::model::SdkEvent::PaymentRefundPending { details } => {
9365 <i32>::sse_encode(4, serializer);
9366 <crate::model::Payment>::sse_encode(details, serializer);
9367 }
9368 crate::model::SdkEvent::PaymentSucceeded { details } => {
9369 <i32>::sse_encode(5, serializer);
9370 <crate::model::Payment>::sse_encode(details, serializer);
9371 }
9372 crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
9373 <i32>::sse_encode(6, serializer);
9374 <crate::model::Payment>::sse_encode(details, serializer);
9375 }
9376 crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
9377 <i32>::sse_encode(7, serializer);
9378 <crate::model::Payment>::sse_encode(details, serializer);
9379 }
9380 crate::model::SdkEvent::Synced => {
9381 <i32>::sse_encode(8, serializer);
9382 }
9383 crate::model::SdkEvent::DataSynced {
9384 did_pull_new_records,
9385 } => {
9386 <i32>::sse_encode(9, serializer);
9387 <bool>::sse_encode(did_pull_new_records, serializer);
9388 }
9389 _ => {
9390 unimplemented!("");
9391 }
9392 }
9393 }
9394}
9395
9396impl SseEncode for crate::model::SendDestination {
9397 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9399 match self {
9400 crate::model::SendDestination::LiquidAddress {
9401 address_data,
9402 bip353_address,
9403 } => {
9404 <i32>::sse_encode(0, serializer);
9405 <crate::bindings::LiquidAddressData>::sse_encode(address_data, serializer);
9406 <Option<String>>::sse_encode(bip353_address, serializer);
9407 }
9408 crate::model::SendDestination::Bolt11 {
9409 invoice,
9410 bip353_address,
9411 } => {
9412 <i32>::sse_encode(1, serializer);
9413 <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
9414 <Option<String>>::sse_encode(bip353_address, serializer);
9415 }
9416 crate::model::SendDestination::Bolt12 {
9417 offer,
9418 receiver_amount_sat,
9419 bip353_address,
9420 } => {
9421 <i32>::sse_encode(2, serializer);
9422 <crate::bindings::LNOffer>::sse_encode(offer, serializer);
9423 <u64>::sse_encode(receiver_amount_sat, serializer);
9424 <Option<String>>::sse_encode(bip353_address, serializer);
9425 }
9426 _ => {
9427 unimplemented!("");
9428 }
9429 }
9430 }
9431}
9432
9433impl SseEncode for crate::model::SendPaymentRequest {
9434 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9436 <crate::model::PrepareSendResponse>::sse_encode(self.prepare_response, serializer);
9437 <Option<bool>>::sse_encode(self.use_asset_fees, serializer);
9438 <Option<String>>::sse_encode(self.payer_note, serializer);
9439 }
9440}
9441
9442impl SseEncode for crate::model::SendPaymentResponse {
9443 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9445 <crate::model::Payment>::sse_encode(self.payment, serializer);
9446 }
9447}
9448
9449impl SseEncode for crate::model::SignMessageRequest {
9450 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9452 <String>::sse_encode(self.message, serializer);
9453 }
9454}
9455
9456impl SseEncode for crate::model::SignMessageResponse {
9457 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9459 <String>::sse_encode(self.signature, serializer);
9460 }
9461}
9462
9463impl SseEncode for crate::bindings::SuccessAction {
9464 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9466 match self {
9467 crate::bindings::SuccessAction::Aes { data } => {
9468 <i32>::sse_encode(0, serializer);
9469 <crate::bindings::AesSuccessActionData>::sse_encode(data, serializer);
9470 }
9471 crate::bindings::SuccessAction::Message { data } => {
9472 <i32>::sse_encode(1, serializer);
9473 <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9474 }
9475 crate::bindings::SuccessAction::Url { data } => {
9476 <i32>::sse_encode(2, serializer);
9477 <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9478 }
9479 _ => {
9480 unimplemented!("");
9481 }
9482 }
9483 }
9484}
9485
9486impl SseEncode for crate::bindings::SuccessActionProcessed {
9487 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9489 match self {
9490 crate::bindings::SuccessActionProcessed::Aes { result } => {
9491 <i32>::sse_encode(0, serializer);
9492 <crate::bindings::AesSuccessActionDataResult>::sse_encode(result, serializer);
9493 }
9494 crate::bindings::SuccessActionProcessed::Message { data } => {
9495 <i32>::sse_encode(1, serializer);
9496 <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9497 }
9498 crate::bindings::SuccessActionProcessed::Url { data } => {
9499 <i32>::sse_encode(2, serializer);
9500 <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9501 }
9502 _ => {
9503 unimplemented!("");
9504 }
9505 }
9506 }
9507}
9508
9509impl SseEncode for crate::bindings::Symbol {
9510 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9512 <Option<String>>::sse_encode(self.grapheme, serializer);
9513 <Option<String>>::sse_encode(self.template, serializer);
9514 <Option<bool>>::sse_encode(self.rtl, serializer);
9515 <Option<u32>>::sse_encode(self.position, serializer);
9516 }
9517}
9518
9519impl SseEncode for u16 {
9520 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9522 serializer.cursor.write_u16::<NativeEndian>(self).unwrap();
9523 }
9524}
9525
9526impl SseEncode for u32 {
9527 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9529 serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
9530 }
9531}
9532
9533impl SseEncode for u64 {
9534 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9536 serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
9537 }
9538}
9539
9540impl SseEncode for u8 {
9541 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9543 serializer.cursor.write_u8(self).unwrap();
9544 }
9545}
9546
9547impl SseEncode for () {
9548 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
9550}
9551
9552impl SseEncode for crate::bindings::UrlSuccessActionData {
9553 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9555 <String>::sse_encode(self.description, serializer);
9556 <String>::sse_encode(self.url, serializer);
9557 <bool>::sse_encode(self.matches_callback_domain, serializer);
9558 }
9559}
9560
9561impl SseEncode for usize {
9562 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9564 serializer
9565 .cursor
9566 .write_u64::<NativeEndian>(self as _)
9567 .unwrap();
9568 }
9569}
9570
9571impl SseEncode for crate::model::WalletInfo {
9572 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9574 <u64>::sse_encode(self.balance_sat, serializer);
9575 <u64>::sse_encode(self.pending_send_sat, serializer);
9576 <u64>::sse_encode(self.pending_receive_sat, serializer);
9577 <String>::sse_encode(self.fingerprint, serializer);
9578 <String>::sse_encode(self.pubkey, serializer);
9579 <Vec<crate::model::AssetBalance>>::sse_encode(self.asset_balances, serializer);
9580 }
9581}
9582
9583#[cfg(not(target_family = "wasm"))]
9584mod io {
9585 use super::*;
9591 use crate::bindings::*;
9592 use crate::model::EventListener;
9593 use flutter_rust_bridge::for_generated::byteorder::{
9594 NativeEndian, ReadBytesExt, WriteBytesExt,
9595 };
9596 use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
9597 use flutter_rust_bridge::{Handler, IntoIntoDart};
9598
9599 flutter_rust_bridge::frb_generated_boilerplate_io!();
9602
9603 impl CstDecode<flutter_rust_bridge::for_generated::anyhow::Error>
9606 for *mut wire_cst_list_prim_u_8_strict
9607 {
9608 fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error {
9610 unimplemented!()
9611 }
9612 }
9613 impl CstDecode<BindingLiquidSdk> for usize {
9614 fn cst_decode(self) -> BindingLiquidSdk {
9616 flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::<
9617 RustOpaqueNom<
9618 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9619 >,
9620 >::cst_decode(
9621 self
9622 ))
9623 }
9624 }
9625 impl
9626 CstDecode<
9627 RustOpaqueNom<
9628 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9629 >,
9630 > for usize
9631 {
9632 fn cst_decode(
9634 self,
9635 ) -> RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
9636 {
9637 unsafe { decode_rust_opaque_nom(self as _) }
9638 }
9639 }
9640 impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>
9641 for *mut wire_cst_list_prim_u_8_strict
9642 {
9643 fn cst_decode(
9645 self,
9646 ) -> StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
9647 {
9648 let raw: String = self.cst_decode();
9649 StreamSink::deserialize(raw)
9650 }
9651 }
9652 impl CstDecode<StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>>
9653 for *mut wire_cst_list_prim_u_8_strict
9654 {
9655 fn cst_decode(
9657 self,
9658 ) -> StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
9659 {
9660 let raw: String = self.cst_decode();
9661 StreamSink::deserialize(raw)
9662 }
9663 }
9664 impl CstDecode<String> for *mut wire_cst_list_prim_u_8_strict {
9665 fn cst_decode(self) -> String {
9667 let vec: Vec<u8> = self.cst_decode();
9668 String::from_utf8(vec).unwrap()
9669 }
9670 }
9671 impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9672 for wire_cst_accept_payment_proposed_fees_request
9673 {
9674 fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9676 crate::model::AcceptPaymentProposedFeesRequest {
9677 response: self.response.cst_decode(),
9678 }
9679 }
9680 }
9681 impl CstDecode<crate::bindings::AesSuccessActionData> for wire_cst_aes_success_action_data {
9682 fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9684 crate::bindings::AesSuccessActionData {
9685 description: self.description.cst_decode(),
9686 ciphertext: self.ciphertext.cst_decode(),
9687 iv: self.iv.cst_decode(),
9688 }
9689 }
9690 }
9691 impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9692 for wire_cst_aes_success_action_data_decrypted
9693 {
9694 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9696 crate::bindings::AesSuccessActionDataDecrypted {
9697 description: self.description.cst_decode(),
9698 plaintext: self.plaintext.cst_decode(),
9699 }
9700 }
9701 }
9702 impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9703 for wire_cst_aes_success_action_data_result
9704 {
9705 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9707 match self.tag {
9708 0 => {
9709 let ans = unsafe { self.kind.Decrypted };
9710 crate::bindings::AesSuccessActionDataResult::Decrypted {
9711 data: ans.data.cst_decode(),
9712 }
9713 }
9714 1 => {
9715 let ans = unsafe { self.kind.ErrorStatus };
9716 crate::bindings::AesSuccessActionDataResult::ErrorStatus {
9717 reason: ans.reason.cst_decode(),
9718 }
9719 }
9720 _ => unreachable!(),
9721 }
9722 }
9723 }
9724 impl CstDecode<crate::bindings::Amount> for wire_cst_amount {
9725 fn cst_decode(self) -> crate::bindings::Amount {
9727 match self.tag {
9728 0 => {
9729 let ans = unsafe { self.kind.Bitcoin };
9730 crate::bindings::Amount::Bitcoin {
9731 amount_msat: ans.amount_msat.cst_decode(),
9732 }
9733 }
9734 1 => {
9735 let ans = unsafe { self.kind.Currency };
9736 crate::bindings::Amount::Currency {
9737 iso4217_code: ans.iso4217_code.cst_decode(),
9738 fractional_amount: ans.fractional_amount.cst_decode(),
9739 }
9740 }
9741 _ => unreachable!(),
9742 }
9743 }
9744 }
9745 impl CstDecode<crate::model::AssetBalance> for wire_cst_asset_balance {
9746 fn cst_decode(self) -> crate::model::AssetBalance {
9748 crate::model::AssetBalance {
9749 asset_id: self.asset_id.cst_decode(),
9750 balance_sat: self.balance_sat.cst_decode(),
9751 name: self.name.cst_decode(),
9752 ticker: self.ticker.cst_decode(),
9753 balance: self.balance.cst_decode(),
9754 }
9755 }
9756 }
9757 impl CstDecode<crate::model::AssetInfo> for wire_cst_asset_info {
9758 fn cst_decode(self) -> crate::model::AssetInfo {
9760 crate::model::AssetInfo {
9761 name: self.name.cst_decode(),
9762 ticker: self.ticker.cst_decode(),
9763 amount: self.amount.cst_decode(),
9764 fees: self.fees.cst_decode(),
9765 }
9766 }
9767 }
9768 impl CstDecode<crate::model::AssetMetadata> for wire_cst_asset_metadata {
9769 fn cst_decode(self) -> crate::model::AssetMetadata {
9771 crate::model::AssetMetadata {
9772 asset_id: self.asset_id.cst_decode(),
9773 name: self.name.cst_decode(),
9774 ticker: self.ticker.cst_decode(),
9775 precision: self.precision.cst_decode(),
9776 fiat_id: self.fiat_id.cst_decode(),
9777 }
9778 }
9779 }
9780 impl CstDecode<crate::model::BackupRequest> for wire_cst_backup_request {
9781 fn cst_decode(self) -> crate::model::BackupRequest {
9783 crate::model::BackupRequest {
9784 backup_path: self.backup_path.cst_decode(),
9785 }
9786 }
9787 }
9788 impl CstDecode<crate::bindings::BindingEventListener> for wire_cst_binding_event_listener {
9789 fn cst_decode(self) -> crate::bindings::BindingEventListener {
9791 crate::bindings::BindingEventListener {
9792 stream: self.stream.cst_decode(),
9793 }
9794 }
9795 }
9796 impl CstDecode<crate::bindings::BitcoinAddressData> for wire_cst_bitcoin_address_data {
9797 fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9799 crate::bindings::BitcoinAddressData {
9800 address: self.address.cst_decode(),
9801 network: self.network.cst_decode(),
9802 amount_sat: self.amount_sat.cst_decode(),
9803 label: self.label.cst_decode(),
9804 message: self.message.cst_decode(),
9805 }
9806 }
9807 }
9808 impl CstDecode<crate::model::BlockchainExplorer> for wire_cst_blockchain_explorer {
9809 fn cst_decode(self) -> crate::model::BlockchainExplorer {
9811 match self.tag {
9812 0 => {
9813 let ans = unsafe { self.kind.Electrum };
9814 crate::model::BlockchainExplorer::Electrum {
9815 url: ans.url.cst_decode(),
9816 }
9817 }
9818 1 => {
9819 let ans = unsafe { self.kind.Esplora };
9820 crate::model::BlockchainExplorer::Esplora {
9821 url: ans.url.cst_decode(),
9822 use_waterfalls: ans.use_waterfalls.cst_decode(),
9823 }
9824 }
9825 _ => unreachable!(),
9826 }
9827 }
9828 }
9829 impl CstDecode<crate::model::BlockchainInfo> for wire_cst_blockchain_info {
9830 fn cst_decode(self) -> crate::model::BlockchainInfo {
9832 crate::model::BlockchainInfo {
9833 liquid_tip: self.liquid_tip.cst_decode(),
9834 bitcoin_tip: self.bitcoin_tip.cst_decode(),
9835 }
9836 }
9837 }
9838 impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9839 for *mut wire_cst_accept_payment_proposed_fees_request
9840 {
9841 fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9843 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9844 CstDecode::<crate::model::AcceptPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9845 }
9846 }
9847 impl CstDecode<crate::bindings::AesSuccessActionData> for *mut wire_cst_aes_success_action_data {
9848 fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9850 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9851 CstDecode::<crate::bindings::AesSuccessActionData>::cst_decode(*wrap).into()
9852 }
9853 }
9854 impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9855 for *mut wire_cst_aes_success_action_data_decrypted
9856 {
9857 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9859 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9860 CstDecode::<crate::bindings::AesSuccessActionDataDecrypted>::cst_decode(*wrap).into()
9861 }
9862 }
9863 impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9864 for *mut wire_cst_aes_success_action_data_result
9865 {
9866 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9868 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9869 CstDecode::<crate::bindings::AesSuccessActionDataResult>::cst_decode(*wrap).into()
9870 }
9871 }
9872 impl CstDecode<crate::bindings::Amount> for *mut wire_cst_amount {
9873 fn cst_decode(self) -> crate::bindings::Amount {
9875 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9876 CstDecode::<crate::bindings::Amount>::cst_decode(*wrap).into()
9877 }
9878 }
9879 impl CstDecode<crate::model::AssetInfo> for *mut wire_cst_asset_info {
9880 fn cst_decode(self) -> crate::model::AssetInfo {
9882 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9883 CstDecode::<crate::model::AssetInfo>::cst_decode(*wrap).into()
9884 }
9885 }
9886 impl CstDecode<crate::model::BackupRequest> for *mut wire_cst_backup_request {
9887 fn cst_decode(self) -> crate::model::BackupRequest {
9889 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9890 CstDecode::<crate::model::BackupRequest>::cst_decode(*wrap).into()
9891 }
9892 }
9893 impl CstDecode<crate::bindings::BindingEventListener> for *mut wire_cst_binding_event_listener {
9894 fn cst_decode(self) -> crate::bindings::BindingEventListener {
9896 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9897 CstDecode::<crate::bindings::BindingEventListener>::cst_decode(*wrap).into()
9898 }
9899 }
9900 impl CstDecode<crate::bindings::BitcoinAddressData> for *mut wire_cst_bitcoin_address_data {
9901 fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9903 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9904 CstDecode::<crate::bindings::BitcoinAddressData>::cst_decode(*wrap).into()
9905 }
9906 }
9907 impl CstDecode<bool> for *mut bool {
9908 fn cst_decode(self) -> bool {
9910 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9911 }
9912 }
9913 impl CstDecode<crate::model::BuyBitcoinRequest> for *mut wire_cst_buy_bitcoin_request {
9914 fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
9916 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9917 CstDecode::<crate::model::BuyBitcoinRequest>::cst_decode(*wrap).into()
9918 }
9919 }
9920 impl CstDecode<crate::model::CheckMessageRequest> for *mut wire_cst_check_message_request {
9921 fn cst_decode(self) -> crate::model::CheckMessageRequest {
9923 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9924 CstDecode::<crate::model::CheckMessageRequest>::cst_decode(*wrap).into()
9925 }
9926 }
9927 impl CstDecode<crate::model::ConnectRequest> for *mut wire_cst_connect_request {
9928 fn cst_decode(self) -> crate::model::ConnectRequest {
9930 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9931 CstDecode::<crate::model::ConnectRequest>::cst_decode(*wrap).into()
9932 }
9933 }
9934 impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
9935 for *mut wire_cst_create_bolt_12_invoice_request
9936 {
9937 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
9939 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9940 CstDecode::<crate::model::CreateBolt12InvoiceRequest>::cst_decode(*wrap).into()
9941 }
9942 }
9943 impl CstDecode<f64> for *mut f64 {
9944 fn cst_decode(self) -> f64 {
9946 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9947 }
9948 }
9949 impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
9950 for *mut wire_cst_fetch_payment_proposed_fees_request
9951 {
9952 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
9954 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9955 CstDecode::<crate::model::FetchPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9956 }
9957 }
9958 impl CstDecode<crate::model::GetPaymentRequest> for *mut wire_cst_get_payment_request {
9959 fn cst_decode(self) -> crate::model::GetPaymentRequest {
9961 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9962 CstDecode::<crate::model::GetPaymentRequest>::cst_decode(*wrap).into()
9963 }
9964 }
9965 impl CstDecode<i64> for *mut i64 {
9966 fn cst_decode(self) -> i64 {
9968 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9969 }
9970 }
9971 impl CstDecode<crate::bindings::LiquidAddressData> for *mut wire_cst_liquid_address_data {
9972 fn cst_decode(self) -> crate::bindings::LiquidAddressData {
9974 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9975 CstDecode::<crate::bindings::LiquidAddressData>::cst_decode(*wrap).into()
9976 }
9977 }
9978 impl CstDecode<crate::model::ListPaymentDetails> for *mut wire_cst_list_payment_details {
9979 fn cst_decode(self) -> crate::model::ListPaymentDetails {
9981 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9982 CstDecode::<crate::model::ListPaymentDetails>::cst_decode(*wrap).into()
9983 }
9984 }
9985 impl CstDecode<crate::model::ListPaymentsRequest> for *mut wire_cst_list_payments_request {
9986 fn cst_decode(self) -> crate::model::ListPaymentsRequest {
9988 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9989 CstDecode::<crate::model::ListPaymentsRequest>::cst_decode(*wrap).into()
9990 }
9991 }
9992 impl CstDecode<crate::bindings::LNInvoice> for *mut wire_cst_ln_invoice {
9993 fn cst_decode(self) -> crate::bindings::LNInvoice {
9995 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9996 CstDecode::<crate::bindings::LNInvoice>::cst_decode(*wrap).into()
9997 }
9998 }
9999 impl CstDecode<crate::bindings::LNOffer> for *mut wire_cst_ln_offer {
10000 fn cst_decode(self) -> crate::bindings::LNOffer {
10002 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10003 CstDecode::<crate::bindings::LNOffer>::cst_decode(*wrap).into()
10004 }
10005 }
10006 impl CstDecode<crate::bindings::LnUrlAuthRequestData> for *mut wire_cst_ln_url_auth_request_data {
10007 fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10009 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10010 CstDecode::<crate::bindings::LnUrlAuthRequestData>::cst_decode(*wrap).into()
10011 }
10012 }
10013 impl CstDecode<crate::bindings::LnUrlErrorData> for *mut wire_cst_ln_url_error_data {
10014 fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10016 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10017 CstDecode::<crate::bindings::LnUrlErrorData>::cst_decode(*wrap).into()
10018 }
10019 }
10020 impl CstDecode<crate::model::LnUrlInfo> for *mut wire_cst_ln_url_info {
10021 fn cst_decode(self) -> crate::model::LnUrlInfo {
10023 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10024 CstDecode::<crate::model::LnUrlInfo>::cst_decode(*wrap).into()
10025 }
10026 }
10027 impl CstDecode<crate::bindings::LnUrlPayErrorData> for *mut wire_cst_ln_url_pay_error_data {
10028 fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10030 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10031 CstDecode::<crate::bindings::LnUrlPayErrorData>::cst_decode(*wrap).into()
10032 }
10033 }
10034 impl CstDecode<crate::model::LnUrlPayRequest> for *mut wire_cst_ln_url_pay_request {
10035 fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10037 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10038 CstDecode::<crate::model::LnUrlPayRequest>::cst_decode(*wrap).into()
10039 }
10040 }
10041 impl CstDecode<crate::bindings::LnUrlPayRequestData> for *mut wire_cst_ln_url_pay_request_data {
10042 fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10044 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10045 CstDecode::<crate::bindings::LnUrlPayRequestData>::cst_decode(*wrap).into()
10046 }
10047 }
10048 impl CstDecode<crate::model::LnUrlPaySuccessData> for *mut wire_cst_ln_url_pay_success_data {
10049 fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10051 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10052 CstDecode::<crate::model::LnUrlPaySuccessData>::cst_decode(*wrap).into()
10053 }
10054 }
10055 impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for *mut wire_cst_ln_url_withdraw_request {
10056 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
10058 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10059 CstDecode::<crate::bindings::LnUrlWithdrawRequest>::cst_decode(*wrap).into()
10060 }
10061 }
10062 impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
10063 for *mut wire_cst_ln_url_withdraw_request_data
10064 {
10065 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
10067 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10068 CstDecode::<crate::bindings::LnUrlWithdrawRequestData>::cst_decode(*wrap).into()
10069 }
10070 }
10071 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
10072 for *mut wire_cst_ln_url_withdraw_success_data
10073 {
10074 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
10076 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10077 CstDecode::<crate::bindings::duplicates::LnUrlWithdrawSuccessData>::cst_decode(*wrap)
10078 .into()
10079 }
10080 }
10081 impl CstDecode<crate::bindings::MessageSuccessActionData>
10082 for *mut wire_cst_message_success_action_data
10083 {
10084 fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
10086 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10087 CstDecode::<crate::bindings::MessageSuccessActionData>::cst_decode(*wrap).into()
10088 }
10089 }
10090 impl CstDecode<crate::model::PayAmount> for *mut wire_cst_pay_amount {
10091 fn cst_decode(self) -> crate::model::PayAmount {
10093 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10094 CstDecode::<crate::model::PayAmount>::cst_decode(*wrap).into()
10095 }
10096 }
10097 impl CstDecode<crate::model::PayOnchainRequest> for *mut wire_cst_pay_onchain_request {
10098 fn cst_decode(self) -> crate::model::PayOnchainRequest {
10100 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10101 CstDecode::<crate::model::PayOnchainRequest>::cst_decode(*wrap).into()
10102 }
10103 }
10104 impl CstDecode<crate::model::Payment> for *mut wire_cst_payment {
10105 fn cst_decode(self) -> crate::model::Payment {
10107 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10108 CstDecode::<crate::model::Payment>::cst_decode(*wrap).into()
10109 }
10110 }
10111 impl CstDecode<crate::model::PrepareBuyBitcoinRequest>
10112 for *mut wire_cst_prepare_buy_bitcoin_request
10113 {
10114 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
10116 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10117 CstDecode::<crate::model::PrepareBuyBitcoinRequest>::cst_decode(*wrap).into()
10118 }
10119 }
10120 impl CstDecode<crate::model::PrepareLnUrlPayRequest> for *mut wire_cst_prepare_ln_url_pay_request {
10121 fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
10123 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10124 CstDecode::<crate::model::PrepareLnUrlPayRequest>::cst_decode(*wrap).into()
10125 }
10126 }
10127 impl CstDecode<crate::model::PreparePayOnchainRequest>
10128 for *mut wire_cst_prepare_pay_onchain_request
10129 {
10130 fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
10132 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10133 CstDecode::<crate::model::PreparePayOnchainRequest>::cst_decode(*wrap).into()
10134 }
10135 }
10136 impl CstDecode<crate::model::PrepareReceiveRequest> for *mut wire_cst_prepare_receive_request {
10137 fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
10139 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10140 CstDecode::<crate::model::PrepareReceiveRequest>::cst_decode(*wrap).into()
10141 }
10142 }
10143 impl CstDecode<crate::model::PrepareRefundRequest> for *mut wire_cst_prepare_refund_request {
10144 fn cst_decode(self) -> crate::model::PrepareRefundRequest {
10146 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10147 CstDecode::<crate::model::PrepareRefundRequest>::cst_decode(*wrap).into()
10148 }
10149 }
10150 impl CstDecode<crate::model::PrepareSendRequest> for *mut wire_cst_prepare_send_request {
10151 fn cst_decode(self) -> crate::model::PrepareSendRequest {
10153 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10154 CstDecode::<crate::model::PrepareSendRequest>::cst_decode(*wrap).into()
10155 }
10156 }
10157 impl CstDecode<crate::model::ReceiveAmount> for *mut wire_cst_receive_amount {
10158 fn cst_decode(self) -> crate::model::ReceiveAmount {
10160 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10161 CstDecode::<crate::model::ReceiveAmount>::cst_decode(*wrap).into()
10162 }
10163 }
10164 impl CstDecode<crate::model::ReceivePaymentRequest> for *mut wire_cst_receive_payment_request {
10165 fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
10167 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10168 CstDecode::<crate::model::ReceivePaymentRequest>::cst_decode(*wrap).into()
10169 }
10170 }
10171 impl CstDecode<crate::model::RefundRequest> for *mut wire_cst_refund_request {
10172 fn cst_decode(self) -> crate::model::RefundRequest {
10174 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10175 CstDecode::<crate::model::RefundRequest>::cst_decode(*wrap).into()
10176 }
10177 }
10178 impl CstDecode<crate::model::RestoreRequest> for *mut wire_cst_restore_request {
10179 fn cst_decode(self) -> crate::model::RestoreRequest {
10181 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10182 CstDecode::<crate::model::RestoreRequest>::cst_decode(*wrap).into()
10183 }
10184 }
10185 impl CstDecode<crate::model::SdkEvent> for *mut wire_cst_sdk_event {
10186 fn cst_decode(self) -> crate::model::SdkEvent {
10188 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10189 CstDecode::<crate::model::SdkEvent>::cst_decode(*wrap).into()
10190 }
10191 }
10192 impl CstDecode<crate::model::SendPaymentRequest> for *mut wire_cst_send_payment_request {
10193 fn cst_decode(self) -> crate::model::SendPaymentRequest {
10195 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10196 CstDecode::<crate::model::SendPaymentRequest>::cst_decode(*wrap).into()
10197 }
10198 }
10199 impl CstDecode<crate::model::SignMessageRequest> for *mut wire_cst_sign_message_request {
10200 fn cst_decode(self) -> crate::model::SignMessageRequest {
10202 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10203 CstDecode::<crate::model::SignMessageRequest>::cst_decode(*wrap).into()
10204 }
10205 }
10206 impl CstDecode<crate::bindings::SuccessAction> for *mut wire_cst_success_action {
10207 fn cst_decode(self) -> crate::bindings::SuccessAction {
10209 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10210 CstDecode::<crate::bindings::SuccessAction>::cst_decode(*wrap).into()
10211 }
10212 }
10213 impl CstDecode<crate::bindings::SuccessActionProcessed> for *mut wire_cst_success_action_processed {
10214 fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
10216 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10217 CstDecode::<crate::bindings::SuccessActionProcessed>::cst_decode(*wrap).into()
10218 }
10219 }
10220 impl CstDecode<crate::bindings::Symbol> for *mut wire_cst_symbol {
10221 fn cst_decode(self) -> crate::bindings::Symbol {
10223 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10224 CstDecode::<crate::bindings::Symbol>::cst_decode(*wrap).into()
10225 }
10226 }
10227 impl CstDecode<u32> for *mut u32 {
10228 fn cst_decode(self) -> u32 {
10230 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10231 }
10232 }
10233 impl CstDecode<u64> for *mut u64 {
10234 fn cst_decode(self) -> u64 {
10236 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10237 }
10238 }
10239 impl CstDecode<crate::bindings::UrlSuccessActionData> for *mut wire_cst_url_success_action_data {
10240 fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
10242 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10243 CstDecode::<crate::bindings::UrlSuccessActionData>::cst_decode(*wrap).into()
10244 }
10245 }
10246 impl CstDecode<crate::model::BuyBitcoinRequest> for wire_cst_buy_bitcoin_request {
10247 fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
10249 crate::model::BuyBitcoinRequest {
10250 prepare_response: self.prepare_response.cst_decode(),
10251 redirect_url: self.redirect_url.cst_decode(),
10252 }
10253 }
10254 }
10255 impl CstDecode<crate::model::CheckMessageRequest> for wire_cst_check_message_request {
10256 fn cst_decode(self) -> crate::model::CheckMessageRequest {
10258 crate::model::CheckMessageRequest {
10259 message: self.message.cst_decode(),
10260 pubkey: self.pubkey.cst_decode(),
10261 signature: self.signature.cst_decode(),
10262 }
10263 }
10264 }
10265 impl CstDecode<crate::model::CheckMessageResponse> for wire_cst_check_message_response {
10266 fn cst_decode(self) -> crate::model::CheckMessageResponse {
10268 crate::model::CheckMessageResponse {
10269 is_valid: self.is_valid.cst_decode(),
10270 }
10271 }
10272 }
10273 impl CstDecode<crate::model::Config> for wire_cst_config {
10274 fn cst_decode(self) -> crate::model::Config {
10276 crate::model::Config {
10277 liquid_explorer: self.liquid_explorer.cst_decode(),
10278 bitcoin_explorer: self.bitcoin_explorer.cst_decode(),
10279 working_dir: self.working_dir.cst_decode(),
10280 network: self.network.cst_decode(),
10281 payment_timeout_sec: self.payment_timeout_sec.cst_decode(),
10282 sync_service_url: self.sync_service_url.cst_decode(),
10283 zero_conf_max_amount_sat: self.zero_conf_max_amount_sat.cst_decode(),
10284 breez_api_key: self.breez_api_key.cst_decode(),
10285 external_input_parsers: self.external_input_parsers.cst_decode(),
10286 use_default_external_input_parsers: self
10287 .use_default_external_input_parsers
10288 .cst_decode(),
10289 onchain_fee_rate_leeway_sat: self.onchain_fee_rate_leeway_sat.cst_decode(),
10290 asset_metadata: self.asset_metadata.cst_decode(),
10291 sideswap_api_key: self.sideswap_api_key.cst_decode(),
10292 use_magic_routing_hints: self.use_magic_routing_hints.cst_decode(),
10293 }
10294 }
10295 }
10296 impl CstDecode<crate::model::ConnectRequest> for wire_cst_connect_request {
10297 fn cst_decode(self) -> crate::model::ConnectRequest {
10299 crate::model::ConnectRequest {
10300 config: self.config.cst_decode(),
10301 mnemonic: self.mnemonic.cst_decode(),
10302 passphrase: self.passphrase.cst_decode(),
10303 seed: self.seed.cst_decode(),
10304 }
10305 }
10306 }
10307 impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
10308 for wire_cst_create_bolt_12_invoice_request
10309 {
10310 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
10312 crate::model::CreateBolt12InvoiceRequest {
10313 offer: self.offer.cst_decode(),
10314 invoice_request: self.invoice_request.cst_decode(),
10315 }
10316 }
10317 }
10318 impl CstDecode<crate::model::CreateBolt12InvoiceResponse>
10319 for wire_cst_create_bolt_12_invoice_response
10320 {
10321 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceResponse {
10323 crate::model::CreateBolt12InvoiceResponse {
10324 invoice: self.invoice.cst_decode(),
10325 }
10326 }
10327 }
10328 impl CstDecode<crate::bindings::CurrencyInfo> for wire_cst_currency_info {
10329 fn cst_decode(self) -> crate::bindings::CurrencyInfo {
10331 crate::bindings::CurrencyInfo {
10332 name: self.name.cst_decode(),
10333 fraction_size: self.fraction_size.cst_decode(),
10334 spacing: self.spacing.cst_decode(),
10335 symbol: self.symbol.cst_decode(),
10336 uniq_symbol: self.uniq_symbol.cst_decode(),
10337 localized_name: self.localized_name.cst_decode(),
10338 locale_overrides: self.locale_overrides.cst_decode(),
10339 }
10340 }
10341 }
10342 impl CstDecode<crate::bindings::ExternalInputParser> for wire_cst_external_input_parser {
10343 fn cst_decode(self) -> crate::bindings::ExternalInputParser {
10345 crate::bindings::ExternalInputParser {
10346 provider_id: self.provider_id.cst_decode(),
10347 input_regex: self.input_regex.cst_decode(),
10348 parser_url: self.parser_url.cst_decode(),
10349 }
10350 }
10351 }
10352 impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
10353 for wire_cst_fetch_payment_proposed_fees_request
10354 {
10355 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
10357 crate::model::FetchPaymentProposedFeesRequest {
10358 swap_id: self.swap_id.cst_decode(),
10359 }
10360 }
10361 }
10362 impl CstDecode<crate::model::FetchPaymentProposedFeesResponse>
10363 for wire_cst_fetch_payment_proposed_fees_response
10364 {
10365 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesResponse {
10367 crate::model::FetchPaymentProposedFeesResponse {
10368 swap_id: self.swap_id.cst_decode(),
10369 fees_sat: self.fees_sat.cst_decode(),
10370 payer_amount_sat: self.payer_amount_sat.cst_decode(),
10371 receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
10372 }
10373 }
10374 }
10375 impl CstDecode<crate::bindings::FiatCurrency> for wire_cst_fiat_currency {
10376 fn cst_decode(self) -> crate::bindings::FiatCurrency {
10378 crate::bindings::FiatCurrency {
10379 id: self.id.cst_decode(),
10380 info: self.info.cst_decode(),
10381 }
10382 }
10383 }
10384 impl CstDecode<crate::model::GetInfoResponse> for wire_cst_get_info_response {
10385 fn cst_decode(self) -> crate::model::GetInfoResponse {
10387 crate::model::GetInfoResponse {
10388 wallet_info: self.wallet_info.cst_decode(),
10389 blockchain_info: self.blockchain_info.cst_decode(),
10390 }
10391 }
10392 }
10393 impl CstDecode<crate::model::GetPaymentRequest> for wire_cst_get_payment_request {
10394 fn cst_decode(self) -> crate::model::GetPaymentRequest {
10396 match self.tag {
10397 0 => {
10398 let ans = unsafe { self.kind.PaymentHash };
10399 crate::model::GetPaymentRequest::PaymentHash {
10400 payment_hash: ans.payment_hash.cst_decode(),
10401 }
10402 }
10403 1 => {
10404 let ans = unsafe { self.kind.SwapId };
10405 crate::model::GetPaymentRequest::SwapId {
10406 swap_id: ans.swap_id.cst_decode(),
10407 }
10408 }
10409 _ => unreachable!(),
10410 }
10411 }
10412 }
10413 impl CstDecode<crate::bindings::InputType> for wire_cst_input_type {
10414 fn cst_decode(self) -> crate::bindings::InputType {
10416 match self.tag {
10417 0 => {
10418 let ans = unsafe { self.kind.BitcoinAddress };
10419 crate::bindings::InputType::BitcoinAddress {
10420 address: ans.address.cst_decode(),
10421 }
10422 }
10423 1 => {
10424 let ans = unsafe { self.kind.LiquidAddress };
10425 crate::bindings::InputType::LiquidAddress {
10426 address: ans.address.cst_decode(),
10427 }
10428 }
10429 2 => {
10430 let ans = unsafe { self.kind.Bolt11 };
10431 crate::bindings::InputType::Bolt11 {
10432 invoice: ans.invoice.cst_decode(),
10433 }
10434 }
10435 3 => {
10436 let ans = unsafe { self.kind.Bolt12Offer };
10437 crate::bindings::InputType::Bolt12Offer {
10438 offer: ans.offer.cst_decode(),
10439 bip353_address: ans.bip353_address.cst_decode(),
10440 }
10441 }
10442 4 => {
10443 let ans = unsafe { self.kind.NodeId };
10444 crate::bindings::InputType::NodeId {
10445 node_id: ans.node_id.cst_decode(),
10446 }
10447 }
10448 5 => {
10449 let ans = unsafe { self.kind.Url };
10450 crate::bindings::InputType::Url {
10451 url: ans.url.cst_decode(),
10452 }
10453 }
10454 6 => {
10455 let ans = unsafe { self.kind.LnUrlPay };
10456 crate::bindings::InputType::LnUrlPay {
10457 data: ans.data.cst_decode(),
10458 bip353_address: ans.bip353_address.cst_decode(),
10459 }
10460 }
10461 7 => {
10462 let ans = unsafe { self.kind.LnUrlWithdraw };
10463 crate::bindings::InputType::LnUrlWithdraw {
10464 data: ans.data.cst_decode(),
10465 }
10466 }
10467 8 => {
10468 let ans = unsafe { self.kind.LnUrlAuth };
10469 crate::bindings::InputType::LnUrlAuth {
10470 data: ans.data.cst_decode(),
10471 }
10472 }
10473 9 => {
10474 let ans = unsafe { self.kind.LnUrlError };
10475 crate::bindings::InputType::LnUrlError {
10476 data: ans.data.cst_decode(),
10477 }
10478 }
10479 _ => unreachable!(),
10480 }
10481 }
10482 }
10483 impl CstDecode<crate::model::LightningPaymentLimitsResponse>
10484 for wire_cst_lightning_payment_limits_response
10485 {
10486 fn cst_decode(self) -> crate::model::LightningPaymentLimitsResponse {
10488 crate::model::LightningPaymentLimitsResponse {
10489 send: self.send.cst_decode(),
10490 receive: self.receive.cst_decode(),
10491 }
10492 }
10493 }
10494 impl CstDecode<crate::model::Limits> for wire_cst_limits {
10495 fn cst_decode(self) -> crate::model::Limits {
10497 crate::model::Limits {
10498 min_sat: self.min_sat.cst_decode(),
10499 max_sat: self.max_sat.cst_decode(),
10500 max_zero_conf_sat: self.max_zero_conf_sat.cst_decode(),
10501 }
10502 }
10503 }
10504 impl CstDecode<crate::bindings::LiquidAddressData> for wire_cst_liquid_address_data {
10505 fn cst_decode(self) -> crate::bindings::LiquidAddressData {
10507 crate::bindings::LiquidAddressData {
10508 address: self.address.cst_decode(),
10509 network: self.network.cst_decode(),
10510 asset_id: self.asset_id.cst_decode(),
10511 amount: self.amount.cst_decode(),
10512 amount_sat: self.amount_sat.cst_decode(),
10513 label: self.label.cst_decode(),
10514 message: self.message.cst_decode(),
10515 }
10516 }
10517 }
10518 impl CstDecode<Vec<String>> for *mut wire_cst_list_String {
10519 fn cst_decode(self) -> Vec<String> {
10521 let vec = unsafe {
10522 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10523 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10524 };
10525 vec.into_iter().map(CstDecode::cst_decode).collect()
10526 }
10527 }
10528 impl CstDecode<Vec<crate::model::AssetBalance>> for *mut wire_cst_list_asset_balance {
10529 fn cst_decode(self) -> Vec<crate::model::AssetBalance> {
10531 let vec = unsafe {
10532 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10533 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10534 };
10535 vec.into_iter().map(CstDecode::cst_decode).collect()
10536 }
10537 }
10538 impl CstDecode<Vec<crate::model::AssetMetadata>> for *mut wire_cst_list_asset_metadata {
10539 fn cst_decode(self) -> Vec<crate::model::AssetMetadata> {
10541 let vec = unsafe {
10542 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10543 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10544 };
10545 vec.into_iter().map(CstDecode::cst_decode).collect()
10546 }
10547 }
10548 impl CstDecode<Vec<crate::bindings::ExternalInputParser>>
10549 for *mut wire_cst_list_external_input_parser
10550 {
10551 fn cst_decode(self) -> Vec<crate::bindings::ExternalInputParser> {
10553 let vec = unsafe {
10554 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10555 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10556 };
10557 vec.into_iter().map(CstDecode::cst_decode).collect()
10558 }
10559 }
10560 impl CstDecode<Vec<crate::bindings::FiatCurrency>> for *mut wire_cst_list_fiat_currency {
10561 fn cst_decode(self) -> Vec<crate::bindings::FiatCurrency> {
10563 let vec = unsafe {
10564 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10565 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10566 };
10567 vec.into_iter().map(CstDecode::cst_decode).collect()
10568 }
10569 }
10570 impl CstDecode<Vec<crate::bindings::LnOfferBlindedPath>>
10571 for *mut wire_cst_list_ln_offer_blinded_path
10572 {
10573 fn cst_decode(self) -> Vec<crate::bindings::LnOfferBlindedPath> {
10575 let vec = unsafe {
10576 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10577 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10578 };
10579 vec.into_iter().map(CstDecode::cst_decode).collect()
10580 }
10581 }
10582 impl CstDecode<Vec<crate::bindings::LocaleOverrides>> for *mut wire_cst_list_locale_overrides {
10583 fn cst_decode(self) -> Vec<crate::bindings::LocaleOverrides> {
10585 let vec = unsafe {
10586 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10587 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10588 };
10589 vec.into_iter().map(CstDecode::cst_decode).collect()
10590 }
10591 }
10592 impl CstDecode<Vec<crate::bindings::LocalizedName>> for *mut wire_cst_list_localized_name {
10593 fn cst_decode(self) -> Vec<crate::bindings::LocalizedName> {
10595 let vec = unsafe {
10596 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10597 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10598 };
10599 vec.into_iter().map(CstDecode::cst_decode).collect()
10600 }
10601 }
10602 impl CstDecode<Vec<crate::model::Payment>> for *mut wire_cst_list_payment {
10603 fn cst_decode(self) -> Vec<crate::model::Payment> {
10605 let vec = unsafe {
10606 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10607 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10608 };
10609 vec.into_iter().map(CstDecode::cst_decode).collect()
10610 }
10611 }
10612 impl CstDecode<crate::model::ListPaymentDetails> for wire_cst_list_payment_details {
10613 fn cst_decode(self) -> crate::model::ListPaymentDetails {
10615 match self.tag {
10616 0 => {
10617 let ans = unsafe { self.kind.Liquid };
10618 crate::model::ListPaymentDetails::Liquid {
10619 asset_id: ans.asset_id.cst_decode(),
10620 destination: ans.destination.cst_decode(),
10621 }
10622 }
10623 1 => {
10624 let ans = unsafe { self.kind.Bitcoin };
10625 crate::model::ListPaymentDetails::Bitcoin {
10626 address: ans.address.cst_decode(),
10627 }
10628 }
10629 _ => unreachable!(),
10630 }
10631 }
10632 }
10633 impl CstDecode<Vec<crate::model::PaymentState>> for *mut wire_cst_list_payment_state {
10634 fn cst_decode(self) -> Vec<crate::model::PaymentState> {
10636 let vec = unsafe {
10637 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10638 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10639 };
10640 vec.into_iter().map(CstDecode::cst_decode).collect()
10641 }
10642 }
10643 impl CstDecode<Vec<crate::model::PaymentType>> for *mut wire_cst_list_payment_type {
10644 fn cst_decode(self) -> Vec<crate::model::PaymentType> {
10646 let vec = unsafe {
10647 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10648 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10649 };
10650 vec.into_iter().map(CstDecode::cst_decode).collect()
10651 }
10652 }
10653 impl CstDecode<crate::model::ListPaymentsRequest> for wire_cst_list_payments_request {
10654 fn cst_decode(self) -> crate::model::ListPaymentsRequest {
10656 crate::model::ListPaymentsRequest {
10657 filters: self.filters.cst_decode(),
10658 states: self.states.cst_decode(),
10659 from_timestamp: self.from_timestamp.cst_decode(),
10660 to_timestamp: self.to_timestamp.cst_decode(),
10661 offset: self.offset.cst_decode(),
10662 limit: self.limit.cst_decode(),
10663 details: self.details.cst_decode(),
10664 sort_ascending: self.sort_ascending.cst_decode(),
10665 }
10666 }
10667 }
10668 impl CstDecode<Vec<u8>> for *mut wire_cst_list_prim_u_8_strict {
10669 fn cst_decode(self) -> Vec<u8> {
10671 unsafe {
10672 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10673 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10674 }
10675 }
10676 }
10677 impl CstDecode<Vec<crate::bindings::Rate>> for *mut wire_cst_list_rate {
10678 fn cst_decode(self) -> Vec<crate::bindings::Rate> {
10680 let vec = unsafe {
10681 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10682 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10683 };
10684 vec.into_iter().map(CstDecode::cst_decode).collect()
10685 }
10686 }
10687 impl CstDecode<Vec<crate::model::RefundableSwap>> for *mut wire_cst_list_refundable_swap {
10688 fn cst_decode(self) -> Vec<crate::model::RefundableSwap> {
10690 let vec = unsafe {
10691 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10692 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10693 };
10694 vec.into_iter().map(CstDecode::cst_decode).collect()
10695 }
10696 }
10697 impl CstDecode<Vec<crate::bindings::RouteHint>> for *mut wire_cst_list_route_hint {
10698 fn cst_decode(self) -> Vec<crate::bindings::RouteHint> {
10700 let vec = unsafe {
10701 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10702 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10703 };
10704 vec.into_iter().map(CstDecode::cst_decode).collect()
10705 }
10706 }
10707 impl CstDecode<Vec<crate::bindings::RouteHintHop>> for *mut wire_cst_list_route_hint_hop {
10708 fn cst_decode(self) -> Vec<crate::bindings::RouteHintHop> {
10710 let vec = unsafe {
10711 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10712 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10713 };
10714 vec.into_iter().map(CstDecode::cst_decode).collect()
10715 }
10716 }
10717 impl CstDecode<crate::bindings::LNInvoice> for wire_cst_ln_invoice {
10718 fn cst_decode(self) -> crate::bindings::LNInvoice {
10720 crate::bindings::LNInvoice {
10721 bolt11: self.bolt11.cst_decode(),
10722 network: self.network.cst_decode(),
10723 payee_pubkey: self.payee_pubkey.cst_decode(),
10724 payment_hash: self.payment_hash.cst_decode(),
10725 description: self.description.cst_decode(),
10726 description_hash: self.description_hash.cst_decode(),
10727 amount_msat: self.amount_msat.cst_decode(),
10728 timestamp: self.timestamp.cst_decode(),
10729 expiry: self.expiry.cst_decode(),
10730 routing_hints: self.routing_hints.cst_decode(),
10731 payment_secret: self.payment_secret.cst_decode(),
10732 min_final_cltv_expiry_delta: self.min_final_cltv_expiry_delta.cst_decode(),
10733 }
10734 }
10735 }
10736 impl CstDecode<crate::bindings::LNOffer> for wire_cst_ln_offer {
10737 fn cst_decode(self) -> crate::bindings::LNOffer {
10739 crate::bindings::LNOffer {
10740 offer: self.offer.cst_decode(),
10741 chains: self.chains.cst_decode(),
10742 min_amount: self.min_amount.cst_decode(),
10743 description: self.description.cst_decode(),
10744 absolute_expiry: self.absolute_expiry.cst_decode(),
10745 issuer: self.issuer.cst_decode(),
10746 signing_pubkey: self.signing_pubkey.cst_decode(),
10747 paths: self.paths.cst_decode(),
10748 }
10749 }
10750 }
10751 impl CstDecode<crate::bindings::LnOfferBlindedPath> for wire_cst_ln_offer_blinded_path {
10752 fn cst_decode(self) -> crate::bindings::LnOfferBlindedPath {
10754 crate::bindings::LnOfferBlindedPath {
10755 blinded_hops: self.blinded_hops.cst_decode(),
10756 }
10757 }
10758 }
10759 impl CstDecode<crate::bindings::duplicates::LnUrlAuthError> for wire_cst_ln_url_auth_error {
10760 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlAuthError {
10762 match self.tag {
10763 0 => {
10764 let ans = unsafe { self.kind.Generic };
10765 crate::bindings::duplicates::LnUrlAuthError::Generic {
10766 err: ans.err.cst_decode(),
10767 }
10768 }
10769 1 => {
10770 let ans = unsafe { self.kind.InvalidUri };
10771 crate::bindings::duplicates::LnUrlAuthError::InvalidUri {
10772 err: ans.err.cst_decode(),
10773 }
10774 }
10775 2 => {
10776 let ans = unsafe { self.kind.ServiceConnectivity };
10777 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
10778 err: ans.err.cst_decode(),
10779 }
10780 }
10781 _ => unreachable!(),
10782 }
10783 }
10784 }
10785 impl CstDecode<crate::bindings::LnUrlAuthRequestData> for wire_cst_ln_url_auth_request_data {
10786 fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10788 crate::bindings::LnUrlAuthRequestData {
10789 k1: self.k1.cst_decode(),
10790 action: self.action.cst_decode(),
10791 domain: self.domain.cst_decode(),
10792 url: self.url.cst_decode(),
10793 }
10794 }
10795 }
10796 impl CstDecode<crate::bindings::duplicates::LnUrlCallbackStatus>
10797 for wire_cst_ln_url_callback_status
10798 {
10799 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
10801 match self.tag {
10802 0 => crate::bindings::duplicates::LnUrlCallbackStatus::Ok,
10803 1 => {
10804 let ans = unsafe { self.kind.ErrorStatus };
10805 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
10806 data: ans.data.cst_decode(),
10807 }
10808 }
10809 _ => unreachable!(),
10810 }
10811 }
10812 }
10813 impl CstDecode<crate::bindings::LnUrlErrorData> for wire_cst_ln_url_error_data {
10814 fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10816 crate::bindings::LnUrlErrorData {
10817 reason: self.reason.cst_decode(),
10818 }
10819 }
10820 }
10821 impl CstDecode<crate::model::LnUrlInfo> for wire_cst_ln_url_info {
10822 fn cst_decode(self) -> crate::model::LnUrlInfo {
10824 crate::model::LnUrlInfo {
10825 ln_address: self.ln_address.cst_decode(),
10826 lnurl_pay_comment: self.lnurl_pay_comment.cst_decode(),
10827 lnurl_pay_domain: self.lnurl_pay_domain.cst_decode(),
10828 lnurl_pay_metadata: self.lnurl_pay_metadata.cst_decode(),
10829 lnurl_pay_success_action: self.lnurl_pay_success_action.cst_decode(),
10830 lnurl_pay_unprocessed_success_action: self
10831 .lnurl_pay_unprocessed_success_action
10832 .cst_decode(),
10833 lnurl_withdraw_endpoint: self.lnurl_withdraw_endpoint.cst_decode(),
10834 }
10835 }
10836 }
10837 impl CstDecode<crate::bindings::duplicates::LnUrlPayError> for wire_cst_ln_url_pay_error {
10838 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlPayError {
10840 match self.tag {
10841 0 => crate::bindings::duplicates::LnUrlPayError::AlreadyPaid,
10842 1 => {
10843 let ans = unsafe { self.kind.Generic };
10844 crate::bindings::duplicates::LnUrlPayError::Generic {
10845 err: ans.err.cst_decode(),
10846 }
10847 }
10848 2 => {
10849 let ans = unsafe { self.kind.InsufficientBalance };
10850 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
10851 err: ans.err.cst_decode(),
10852 }
10853 }
10854 3 => {
10855 let ans = unsafe { self.kind.InvalidAmount };
10856 crate::bindings::duplicates::LnUrlPayError::InvalidAmount {
10857 err: ans.err.cst_decode(),
10858 }
10859 }
10860 4 => {
10861 let ans = unsafe { self.kind.InvalidInvoice };
10862 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice {
10863 err: ans.err.cst_decode(),
10864 }
10865 }
10866 5 => {
10867 let ans = unsafe { self.kind.InvalidNetwork };
10868 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork {
10869 err: ans.err.cst_decode(),
10870 }
10871 }
10872 6 => {
10873 let ans = unsafe { self.kind.InvalidUri };
10874 crate::bindings::duplicates::LnUrlPayError::InvalidUri {
10875 err: ans.err.cst_decode(),
10876 }
10877 }
10878 7 => {
10879 let ans = unsafe { self.kind.InvoiceExpired };
10880 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired {
10881 err: ans.err.cst_decode(),
10882 }
10883 }
10884 8 => {
10885 let ans = unsafe { self.kind.PaymentFailed };
10886 crate::bindings::duplicates::LnUrlPayError::PaymentFailed {
10887 err: ans.err.cst_decode(),
10888 }
10889 }
10890 9 => {
10891 let ans = unsafe { self.kind.PaymentTimeout };
10892 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout {
10893 err: ans.err.cst_decode(),
10894 }
10895 }
10896 10 => {
10897 let ans = unsafe { self.kind.RouteNotFound };
10898 crate::bindings::duplicates::LnUrlPayError::RouteNotFound {
10899 err: ans.err.cst_decode(),
10900 }
10901 }
10902 11 => {
10903 let ans = unsafe { self.kind.RouteTooExpensive };
10904 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
10905 err: ans.err.cst_decode(),
10906 }
10907 }
10908 12 => {
10909 let ans = unsafe { self.kind.ServiceConnectivity };
10910 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
10911 err: ans.err.cst_decode(),
10912 }
10913 }
10914 _ => unreachable!(),
10915 }
10916 }
10917 }
10918 impl CstDecode<crate::bindings::LnUrlPayErrorData> for wire_cst_ln_url_pay_error_data {
10919 fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10921 crate::bindings::LnUrlPayErrorData {
10922 payment_hash: self.payment_hash.cst_decode(),
10923 reason: self.reason.cst_decode(),
10924 }
10925 }
10926 }
10927 impl CstDecode<crate::model::LnUrlPayRequest> for wire_cst_ln_url_pay_request {
10928 fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10930 crate::model::LnUrlPayRequest {
10931 prepare_response: self.prepare_response.cst_decode(),
10932 }
10933 }
10934 }
10935 impl CstDecode<crate::bindings::LnUrlPayRequestData> for wire_cst_ln_url_pay_request_data {
10936 fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10938 crate::bindings::LnUrlPayRequestData {
10939 callback: self.callback.cst_decode(),
10940 min_sendable: self.min_sendable.cst_decode(),
10941 max_sendable: self.max_sendable.cst_decode(),
10942 metadata_str: self.metadata_str.cst_decode(),
10943 comment_allowed: self.comment_allowed.cst_decode(),
10944 domain: self.domain.cst_decode(),
10945 allows_nostr: self.allows_nostr.cst_decode(),
10946 nostr_pubkey: self.nostr_pubkey.cst_decode(),
10947 ln_address: self.ln_address.cst_decode(),
10948 }
10949 }
10950 }
10951 impl CstDecode<crate::model::LnUrlPayResult> for wire_cst_ln_url_pay_result {
10952 fn cst_decode(self) -> crate::model::LnUrlPayResult {
10954 match self.tag {
10955 0 => {
10956 let ans = unsafe { self.kind.EndpointSuccess };
10957 crate::model::LnUrlPayResult::EndpointSuccess {
10958 data: ans.data.cst_decode(),
10959 }
10960 }
10961 1 => {
10962 let ans = unsafe { self.kind.EndpointError };
10963 crate::model::LnUrlPayResult::EndpointError {
10964 data: ans.data.cst_decode(),
10965 }
10966 }
10967 2 => {
10968 let ans = unsafe { self.kind.PayError };
10969 crate::model::LnUrlPayResult::PayError {
10970 data: ans.data.cst_decode(),
10971 }
10972 }
10973 _ => unreachable!(),
10974 }
10975 }
10976 }
10977 impl CstDecode<crate::model::LnUrlPaySuccessData> for wire_cst_ln_url_pay_success_data {
10978 fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10980 crate::model::LnUrlPaySuccessData {
10981 payment: self.payment.cst_decode(),
10982 success_action: self.success_action.cst_decode(),
10983 }
10984 }
10985 }
10986 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawError> for wire_cst_ln_url_withdraw_error {
10987 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
10989 match self.tag {
10990 0 => {
10991 let ans = unsafe { self.kind.Generic };
10992 crate::bindings::duplicates::LnUrlWithdrawError::Generic {
10993 err: ans.err.cst_decode(),
10994 }
10995 }
10996 1 => {
10997 let ans = unsafe { self.kind.InvalidAmount };
10998 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
10999 err: ans.err.cst_decode(),
11000 }
11001 }
11002 2 => {
11003 let ans = unsafe { self.kind.InvalidInvoice };
11004 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
11005 err: ans.err.cst_decode(),
11006 }
11007 }
11008 3 => {
11009 let ans = unsafe { self.kind.InvalidUri };
11010 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
11011 err: ans.err.cst_decode(),
11012 }
11013 }
11014 4 => {
11015 let ans = unsafe { self.kind.InvoiceNoRoutingHints };
11016 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
11017 err: ans.err.cst_decode(),
11018 }
11019 }
11020 5 => {
11021 let ans = unsafe { self.kind.ServiceConnectivity };
11022 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
11023 err: ans.err.cst_decode(),
11024 }
11025 }
11026 _ => unreachable!(),
11027 }
11028 }
11029 }
11030 impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for wire_cst_ln_url_withdraw_request {
11031 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
11033 crate::bindings::LnUrlWithdrawRequest {
11034 data: self.data.cst_decode(),
11035 amount_msat: self.amount_msat.cst_decode(),
11036 description: self.description.cst_decode(),
11037 }
11038 }
11039 }
11040 impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
11041 for wire_cst_ln_url_withdraw_request_data
11042 {
11043 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
11045 crate::bindings::LnUrlWithdrawRequestData {
11046 callback: self.callback.cst_decode(),
11047 k1: self.k1.cst_decode(),
11048 default_description: self.default_description.cst_decode(),
11049 min_withdrawable: self.min_withdrawable.cst_decode(),
11050 max_withdrawable: self.max_withdrawable.cst_decode(),
11051 }
11052 }
11053 }
11054 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawResult>
11055 for wire_cst_ln_url_withdraw_result
11056 {
11057 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
11059 match self.tag {
11060 0 => {
11061 let ans = unsafe { self.kind.Ok };
11062 crate::bindings::duplicates::LnUrlWithdrawResult::Ok {
11063 data: ans.data.cst_decode(),
11064 }
11065 }
11066 1 => {
11067 let ans = unsafe { self.kind.Timeout };
11068 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
11069 data: ans.data.cst_decode(),
11070 }
11071 }
11072 2 => {
11073 let ans = unsafe { self.kind.ErrorStatus };
11074 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
11075 data: ans.data.cst_decode(),
11076 }
11077 }
11078 _ => unreachable!(),
11079 }
11080 }
11081 }
11082 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
11083 for wire_cst_ln_url_withdraw_success_data
11084 {
11085 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11087 crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11088 invoice: self.invoice.cst_decode(),
11089 }
11090 }
11091 }
11092 impl CstDecode<crate::bindings::LocaleOverrides> for wire_cst_locale_overrides {
11093 fn cst_decode(self) -> crate::bindings::LocaleOverrides {
11095 crate::bindings::LocaleOverrides {
11096 locale: self.locale.cst_decode(),
11097 spacing: self.spacing.cst_decode(),
11098 symbol: self.symbol.cst_decode(),
11099 }
11100 }
11101 }
11102 impl CstDecode<crate::bindings::LocalizedName> for wire_cst_localized_name {
11103 fn cst_decode(self) -> crate::bindings::LocalizedName {
11105 crate::bindings::LocalizedName {
11106 locale: self.locale.cst_decode(),
11107 name: self.name.cst_decode(),
11108 }
11109 }
11110 }
11111 impl CstDecode<crate::model::LogEntry> for wire_cst_log_entry {
11112 fn cst_decode(self) -> crate::model::LogEntry {
11114 crate::model::LogEntry {
11115 line: self.line.cst_decode(),
11116 level: self.level.cst_decode(),
11117 }
11118 }
11119 }
11120 impl CstDecode<crate::bindings::MessageSuccessActionData> for wire_cst_message_success_action_data {
11121 fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
11123 crate::bindings::MessageSuccessActionData {
11124 message: self.message.cst_decode(),
11125 }
11126 }
11127 }
11128 impl CstDecode<crate::model::OnchainPaymentLimitsResponse>
11129 for wire_cst_onchain_payment_limits_response
11130 {
11131 fn cst_decode(self) -> crate::model::OnchainPaymentLimitsResponse {
11133 crate::model::OnchainPaymentLimitsResponse {
11134 send: self.send.cst_decode(),
11135 receive: self.receive.cst_decode(),
11136 }
11137 }
11138 }
11139 impl CstDecode<crate::model::PayAmount> for wire_cst_pay_amount {
11140 fn cst_decode(self) -> crate::model::PayAmount {
11142 match self.tag {
11143 0 => {
11144 let ans = unsafe { self.kind.Bitcoin };
11145 crate::model::PayAmount::Bitcoin {
11146 receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11147 }
11148 }
11149 1 => {
11150 let ans = unsafe { self.kind.Asset };
11151 crate::model::PayAmount::Asset {
11152 to_asset: ans.to_asset.cst_decode(),
11153 receiver_amount: ans.receiver_amount.cst_decode(),
11154 estimate_asset_fees: ans.estimate_asset_fees.cst_decode(),
11155 from_asset: ans.from_asset.cst_decode(),
11156 }
11157 }
11158 2 => crate::model::PayAmount::Drain,
11159 _ => unreachable!(),
11160 }
11161 }
11162 }
11163 impl CstDecode<crate::model::PayOnchainRequest> for wire_cst_pay_onchain_request {
11164 fn cst_decode(self) -> crate::model::PayOnchainRequest {
11166 crate::model::PayOnchainRequest {
11167 address: self.address.cst_decode(),
11168 prepare_response: self.prepare_response.cst_decode(),
11169 }
11170 }
11171 }
11172 impl CstDecode<crate::model::Payment> for wire_cst_payment {
11173 fn cst_decode(self) -> crate::model::Payment {
11175 crate::model::Payment {
11176 destination: self.destination.cst_decode(),
11177 tx_id: self.tx_id.cst_decode(),
11178 unblinding_data: self.unblinding_data.cst_decode(),
11179 timestamp: self.timestamp.cst_decode(),
11180 amount_sat: self.amount_sat.cst_decode(),
11181 fees_sat: self.fees_sat.cst_decode(),
11182 swapper_fees_sat: self.swapper_fees_sat.cst_decode(),
11183 payment_type: self.payment_type.cst_decode(),
11184 status: self.status.cst_decode(),
11185 details: self.details.cst_decode(),
11186 }
11187 }
11188 }
11189 impl CstDecode<crate::model::PaymentDetails> for wire_cst_payment_details {
11190 fn cst_decode(self) -> crate::model::PaymentDetails {
11192 match self.tag {
11193 0 => {
11194 let ans = unsafe { self.kind.Lightning };
11195 crate::model::PaymentDetails::Lightning {
11196 swap_id: ans.swap_id.cst_decode(),
11197 description: ans.description.cst_decode(),
11198 liquid_expiration_blockheight: ans
11199 .liquid_expiration_blockheight
11200 .cst_decode(),
11201 preimage: ans.preimage.cst_decode(),
11202 invoice: ans.invoice.cst_decode(),
11203 bolt12_offer: ans.bolt12_offer.cst_decode(),
11204 payment_hash: ans.payment_hash.cst_decode(),
11205 destination_pubkey: ans.destination_pubkey.cst_decode(),
11206 lnurl_info: ans.lnurl_info.cst_decode(),
11207 bip353_address: ans.bip353_address.cst_decode(),
11208 payer_note: ans.payer_note.cst_decode(),
11209 claim_tx_id: ans.claim_tx_id.cst_decode(),
11210 refund_tx_id: ans.refund_tx_id.cst_decode(),
11211 refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11212 }
11213 }
11214 1 => {
11215 let ans = unsafe { self.kind.Liquid };
11216 crate::model::PaymentDetails::Liquid {
11217 destination: ans.destination.cst_decode(),
11218 description: ans.description.cst_decode(),
11219 asset_id: ans.asset_id.cst_decode(),
11220 asset_info: ans.asset_info.cst_decode(),
11221 lnurl_info: ans.lnurl_info.cst_decode(),
11222 bip353_address: ans.bip353_address.cst_decode(),
11223 payer_note: ans.payer_note.cst_decode(),
11224 }
11225 }
11226 2 => {
11227 let ans = unsafe { self.kind.Bitcoin };
11228 crate::model::PaymentDetails::Bitcoin {
11229 swap_id: ans.swap_id.cst_decode(),
11230 bitcoin_address: ans.bitcoin_address.cst_decode(),
11231 description: ans.description.cst_decode(),
11232 auto_accepted_fees: ans.auto_accepted_fees.cst_decode(),
11233 liquid_expiration_blockheight: ans
11234 .liquid_expiration_blockheight
11235 .cst_decode(),
11236 bitcoin_expiration_blockheight: ans
11237 .bitcoin_expiration_blockheight
11238 .cst_decode(),
11239 lockup_tx_id: ans.lockup_tx_id.cst_decode(),
11240 claim_tx_id: ans.claim_tx_id.cst_decode(),
11241 refund_tx_id: ans.refund_tx_id.cst_decode(),
11242 refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11243 }
11244 }
11245 _ => unreachable!(),
11246 }
11247 }
11248 }
11249 impl CstDecode<crate::error::PaymentError> for wire_cst_payment_error {
11250 fn cst_decode(self) -> crate::error::PaymentError {
11252 match self.tag {
11253 0 => crate::error::PaymentError::AlreadyClaimed,
11254 1 => crate::error::PaymentError::AlreadyPaid,
11255 2 => crate::error::PaymentError::PaymentInProgress,
11256 3 => {
11257 let ans = unsafe { self.kind.AmountOutOfRange };
11258 crate::error::PaymentError::AmountOutOfRange {
11259 min: ans.min.cst_decode(),
11260 max: ans.max.cst_decode(),
11261 }
11262 }
11263 4 => {
11264 let ans = unsafe { self.kind.AmountMissing };
11265 crate::error::PaymentError::AmountMissing {
11266 err: ans.err.cst_decode(),
11267 }
11268 }
11269 5 => {
11270 let ans = unsafe { self.kind.AssetError };
11271 crate::error::PaymentError::AssetError {
11272 err: ans.err.cst_decode(),
11273 }
11274 }
11275 6 => {
11276 let ans = unsafe { self.kind.InvalidNetwork };
11277 crate::error::PaymentError::InvalidNetwork {
11278 err: ans.err.cst_decode(),
11279 }
11280 }
11281 7 => {
11282 let ans = unsafe { self.kind.Generic };
11283 crate::error::PaymentError::Generic {
11284 err: ans.err.cst_decode(),
11285 }
11286 }
11287 8 => crate::error::PaymentError::InvalidOrExpiredFees,
11288 9 => crate::error::PaymentError::InsufficientFunds,
11289 10 => {
11290 let ans = unsafe { self.kind.InvalidDescription };
11291 crate::error::PaymentError::InvalidDescription {
11292 err: ans.err.cst_decode(),
11293 }
11294 }
11295 11 => {
11296 let ans = unsafe { self.kind.InvalidInvoice };
11297 crate::error::PaymentError::InvalidInvoice {
11298 err: ans.err.cst_decode(),
11299 }
11300 }
11301 12 => crate::error::PaymentError::InvalidPreimage,
11302 13 => crate::error::PaymentError::PairsNotFound,
11303 14 => crate::error::PaymentError::PaymentTimeout,
11304 15 => crate::error::PaymentError::PersistError,
11305 16 => {
11306 let ans = unsafe { self.kind.ReceiveError };
11307 crate::error::PaymentError::ReceiveError {
11308 err: ans.err.cst_decode(),
11309 }
11310 }
11311 17 => {
11312 let ans = unsafe { self.kind.Refunded };
11313 crate::error::PaymentError::Refunded {
11314 err: ans.err.cst_decode(),
11315 refund_tx_id: ans.refund_tx_id.cst_decode(),
11316 }
11317 }
11318 18 => crate::error::PaymentError::SelfTransferNotSupported,
11319 19 => {
11320 let ans = unsafe { self.kind.SendError };
11321 crate::error::PaymentError::SendError {
11322 err: ans.err.cst_decode(),
11323 }
11324 }
11325 20 => {
11326 let ans = unsafe { self.kind.SignerError };
11327 crate::error::PaymentError::SignerError {
11328 err: ans.err.cst_decode(),
11329 }
11330 }
11331 _ => unreachable!(),
11332 }
11333 }
11334 }
11335 impl CstDecode<crate::model::PrepareBuyBitcoinRequest> for wire_cst_prepare_buy_bitcoin_request {
11336 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
11338 crate::model::PrepareBuyBitcoinRequest {
11339 provider: self.provider.cst_decode(),
11340 amount_sat: self.amount_sat.cst_decode(),
11341 }
11342 }
11343 }
11344 impl CstDecode<crate::model::PrepareBuyBitcoinResponse> for wire_cst_prepare_buy_bitcoin_response {
11345 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinResponse {
11347 crate::model::PrepareBuyBitcoinResponse {
11348 provider: self.provider.cst_decode(),
11349 amount_sat: self.amount_sat.cst_decode(),
11350 fees_sat: self.fees_sat.cst_decode(),
11351 }
11352 }
11353 }
11354 impl CstDecode<crate::model::PrepareLnUrlPayRequest> for wire_cst_prepare_ln_url_pay_request {
11355 fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
11357 crate::model::PrepareLnUrlPayRequest {
11358 data: self.data.cst_decode(),
11359 amount: self.amount.cst_decode(),
11360 bip353_address: self.bip353_address.cst_decode(),
11361 comment: self.comment.cst_decode(),
11362 validate_success_action_url: self.validate_success_action_url.cst_decode(),
11363 }
11364 }
11365 }
11366 impl CstDecode<crate::model::PrepareLnUrlPayResponse> for wire_cst_prepare_ln_url_pay_response {
11367 fn cst_decode(self) -> crate::model::PrepareLnUrlPayResponse {
11369 crate::model::PrepareLnUrlPayResponse {
11370 destination: self.destination.cst_decode(),
11371 fees_sat: self.fees_sat.cst_decode(),
11372 data: self.data.cst_decode(),
11373 amount: self.amount.cst_decode(),
11374 comment: self.comment.cst_decode(),
11375 success_action: self.success_action.cst_decode(),
11376 }
11377 }
11378 }
11379 impl CstDecode<crate::model::PreparePayOnchainRequest> for wire_cst_prepare_pay_onchain_request {
11380 fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
11382 crate::model::PreparePayOnchainRequest {
11383 amount: self.amount.cst_decode(),
11384 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11385 }
11386 }
11387 }
11388 impl CstDecode<crate::model::PreparePayOnchainResponse> for wire_cst_prepare_pay_onchain_response {
11389 fn cst_decode(self) -> crate::model::PreparePayOnchainResponse {
11391 crate::model::PreparePayOnchainResponse {
11392 receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
11393 claim_fees_sat: self.claim_fees_sat.cst_decode(),
11394 total_fees_sat: self.total_fees_sat.cst_decode(),
11395 }
11396 }
11397 }
11398 impl CstDecode<crate::model::PrepareReceiveRequest> for wire_cst_prepare_receive_request {
11399 fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
11401 crate::model::PrepareReceiveRequest {
11402 payment_method: self.payment_method.cst_decode(),
11403 amount: self.amount.cst_decode(),
11404 }
11405 }
11406 }
11407 impl CstDecode<crate::model::PrepareReceiveResponse> for wire_cst_prepare_receive_response {
11408 fn cst_decode(self) -> crate::model::PrepareReceiveResponse {
11410 crate::model::PrepareReceiveResponse {
11411 payment_method: self.payment_method.cst_decode(),
11412 fees_sat: self.fees_sat.cst_decode(),
11413 amount: self.amount.cst_decode(),
11414 min_payer_amount_sat: self.min_payer_amount_sat.cst_decode(),
11415 max_payer_amount_sat: self.max_payer_amount_sat.cst_decode(),
11416 swapper_feerate: self.swapper_feerate.cst_decode(),
11417 }
11418 }
11419 }
11420 impl CstDecode<crate::model::PrepareRefundRequest> for wire_cst_prepare_refund_request {
11421 fn cst_decode(self) -> crate::model::PrepareRefundRequest {
11423 crate::model::PrepareRefundRequest {
11424 swap_address: self.swap_address.cst_decode(),
11425 refund_address: self.refund_address.cst_decode(),
11426 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11427 }
11428 }
11429 }
11430 impl CstDecode<crate::model::PrepareRefundResponse> for wire_cst_prepare_refund_response {
11431 fn cst_decode(self) -> crate::model::PrepareRefundResponse {
11433 crate::model::PrepareRefundResponse {
11434 tx_vsize: self.tx_vsize.cst_decode(),
11435 tx_fee_sat: self.tx_fee_sat.cst_decode(),
11436 last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11437 }
11438 }
11439 }
11440 impl CstDecode<crate::model::PrepareSendRequest> for wire_cst_prepare_send_request {
11441 fn cst_decode(self) -> crate::model::PrepareSendRequest {
11443 crate::model::PrepareSendRequest {
11444 destination: self.destination.cst_decode(),
11445 amount: self.amount.cst_decode(),
11446 }
11447 }
11448 }
11449 impl CstDecode<crate::model::PrepareSendResponse> for wire_cst_prepare_send_response {
11450 fn cst_decode(self) -> crate::model::PrepareSendResponse {
11452 crate::model::PrepareSendResponse {
11453 destination: self.destination.cst_decode(),
11454 amount: self.amount.cst_decode(),
11455 fees_sat: self.fees_sat.cst_decode(),
11456 estimated_asset_fees: self.estimated_asset_fees.cst_decode(),
11457 exchange_amount_sat: self.exchange_amount_sat.cst_decode(),
11458 }
11459 }
11460 }
11461 impl CstDecode<crate::bindings::Rate> for wire_cst_rate {
11462 fn cst_decode(self) -> crate::bindings::Rate {
11464 crate::bindings::Rate {
11465 coin: self.coin.cst_decode(),
11466 value: self.value.cst_decode(),
11467 }
11468 }
11469 }
11470 impl CstDecode<crate::model::ReceiveAmount> for wire_cst_receive_amount {
11471 fn cst_decode(self) -> crate::model::ReceiveAmount {
11473 match self.tag {
11474 0 => {
11475 let ans = unsafe { self.kind.Bitcoin };
11476 crate::model::ReceiveAmount::Bitcoin {
11477 payer_amount_sat: ans.payer_amount_sat.cst_decode(),
11478 }
11479 }
11480 1 => {
11481 let ans = unsafe { self.kind.Asset };
11482 crate::model::ReceiveAmount::Asset {
11483 asset_id: ans.asset_id.cst_decode(),
11484 payer_amount: ans.payer_amount.cst_decode(),
11485 }
11486 }
11487 _ => unreachable!(),
11488 }
11489 }
11490 }
11491 impl CstDecode<crate::model::ReceivePaymentRequest> for wire_cst_receive_payment_request {
11492 fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
11494 crate::model::ReceivePaymentRequest {
11495 prepare_response: self.prepare_response.cst_decode(),
11496 description: self.description.cst_decode(),
11497 use_description_hash: self.use_description_hash.cst_decode(),
11498 payer_note: self.payer_note.cst_decode(),
11499 }
11500 }
11501 }
11502 impl CstDecode<crate::model::ReceivePaymentResponse> for wire_cst_receive_payment_response {
11503 fn cst_decode(self) -> crate::model::ReceivePaymentResponse {
11505 crate::model::ReceivePaymentResponse {
11506 destination: self.destination.cst_decode(),
11507 }
11508 }
11509 }
11510 impl CstDecode<crate::model::RecommendedFees> for wire_cst_recommended_fees {
11511 fn cst_decode(self) -> crate::model::RecommendedFees {
11513 crate::model::RecommendedFees {
11514 fastest_fee: self.fastest_fee.cst_decode(),
11515 half_hour_fee: self.half_hour_fee.cst_decode(),
11516 hour_fee: self.hour_fee.cst_decode(),
11517 economy_fee: self.economy_fee.cst_decode(),
11518 minimum_fee: self.minimum_fee.cst_decode(),
11519 }
11520 }
11521 }
11522 impl CstDecode<crate::model::RefundRequest> for wire_cst_refund_request {
11523 fn cst_decode(self) -> crate::model::RefundRequest {
11525 crate::model::RefundRequest {
11526 swap_address: self.swap_address.cst_decode(),
11527 refund_address: self.refund_address.cst_decode(),
11528 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11529 }
11530 }
11531 }
11532 impl CstDecode<crate::model::RefundResponse> for wire_cst_refund_response {
11533 fn cst_decode(self) -> crate::model::RefundResponse {
11535 crate::model::RefundResponse {
11536 refund_tx_id: self.refund_tx_id.cst_decode(),
11537 }
11538 }
11539 }
11540 impl CstDecode<crate::model::RefundableSwap> for wire_cst_refundable_swap {
11541 fn cst_decode(self) -> crate::model::RefundableSwap {
11543 crate::model::RefundableSwap {
11544 swap_address: self.swap_address.cst_decode(),
11545 timestamp: self.timestamp.cst_decode(),
11546 amount_sat: self.amount_sat.cst_decode(),
11547 last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11548 }
11549 }
11550 }
11551 impl CstDecode<crate::model::RestoreRequest> for wire_cst_restore_request {
11552 fn cst_decode(self) -> crate::model::RestoreRequest {
11554 crate::model::RestoreRequest {
11555 backup_path: self.backup_path.cst_decode(),
11556 }
11557 }
11558 }
11559 impl CstDecode<crate::bindings::RouteHint> for wire_cst_route_hint {
11560 fn cst_decode(self) -> crate::bindings::RouteHint {
11562 crate::bindings::RouteHint {
11563 hops: self.hops.cst_decode(),
11564 }
11565 }
11566 }
11567 impl CstDecode<crate::bindings::RouteHintHop> for wire_cst_route_hint_hop {
11568 fn cst_decode(self) -> crate::bindings::RouteHintHop {
11570 crate::bindings::RouteHintHop {
11571 src_node_id: self.src_node_id.cst_decode(),
11572 short_channel_id: self.short_channel_id.cst_decode(),
11573 fees_base_msat: self.fees_base_msat.cst_decode(),
11574 fees_proportional_millionths: self.fees_proportional_millionths.cst_decode(),
11575 cltv_expiry_delta: self.cltv_expiry_delta.cst_decode(),
11576 htlc_minimum_msat: self.htlc_minimum_msat.cst_decode(),
11577 htlc_maximum_msat: self.htlc_maximum_msat.cst_decode(),
11578 }
11579 }
11580 }
11581 impl CstDecode<crate::error::SdkError> for wire_cst_sdk_error {
11582 fn cst_decode(self) -> crate::error::SdkError {
11584 match self.tag {
11585 0 => crate::error::SdkError::AlreadyStarted,
11586 1 => {
11587 let ans = unsafe { self.kind.Generic };
11588 crate::error::SdkError::Generic {
11589 err: ans.err.cst_decode(),
11590 }
11591 }
11592 2 => crate::error::SdkError::NotStarted,
11593 3 => {
11594 let ans = unsafe { self.kind.ServiceConnectivity };
11595 crate::error::SdkError::ServiceConnectivity {
11596 err: ans.err.cst_decode(),
11597 }
11598 }
11599 _ => unreachable!(),
11600 }
11601 }
11602 }
11603 impl CstDecode<crate::model::SdkEvent> for wire_cst_sdk_event {
11604 fn cst_decode(self) -> crate::model::SdkEvent {
11606 match self.tag {
11607 0 => {
11608 let ans = unsafe { self.kind.PaymentFailed };
11609 crate::model::SdkEvent::PaymentFailed {
11610 details: ans.details.cst_decode(),
11611 }
11612 }
11613 1 => {
11614 let ans = unsafe { self.kind.PaymentPending };
11615 crate::model::SdkEvent::PaymentPending {
11616 details: ans.details.cst_decode(),
11617 }
11618 }
11619 2 => {
11620 let ans = unsafe { self.kind.PaymentRefundable };
11621 crate::model::SdkEvent::PaymentRefundable {
11622 details: ans.details.cst_decode(),
11623 }
11624 }
11625 3 => {
11626 let ans = unsafe { self.kind.PaymentRefunded };
11627 crate::model::SdkEvent::PaymentRefunded {
11628 details: ans.details.cst_decode(),
11629 }
11630 }
11631 4 => {
11632 let ans = unsafe { self.kind.PaymentRefundPending };
11633 crate::model::SdkEvent::PaymentRefundPending {
11634 details: ans.details.cst_decode(),
11635 }
11636 }
11637 5 => {
11638 let ans = unsafe { self.kind.PaymentSucceeded };
11639 crate::model::SdkEvent::PaymentSucceeded {
11640 details: ans.details.cst_decode(),
11641 }
11642 }
11643 6 => {
11644 let ans = unsafe { self.kind.PaymentWaitingConfirmation };
11645 crate::model::SdkEvent::PaymentWaitingConfirmation {
11646 details: ans.details.cst_decode(),
11647 }
11648 }
11649 7 => {
11650 let ans = unsafe { self.kind.PaymentWaitingFeeAcceptance };
11651 crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
11652 details: ans.details.cst_decode(),
11653 }
11654 }
11655 8 => crate::model::SdkEvent::Synced,
11656 9 => {
11657 let ans = unsafe { self.kind.DataSynced };
11658 crate::model::SdkEvent::DataSynced {
11659 did_pull_new_records: ans.did_pull_new_records.cst_decode(),
11660 }
11661 }
11662 _ => unreachable!(),
11663 }
11664 }
11665 }
11666 impl CstDecode<crate::model::SendDestination> for wire_cst_send_destination {
11667 fn cst_decode(self) -> crate::model::SendDestination {
11669 match self.tag {
11670 0 => {
11671 let ans = unsafe { self.kind.LiquidAddress };
11672 crate::model::SendDestination::LiquidAddress {
11673 address_data: ans.address_data.cst_decode(),
11674 bip353_address: ans.bip353_address.cst_decode(),
11675 }
11676 }
11677 1 => {
11678 let ans = unsafe { self.kind.Bolt11 };
11679 crate::model::SendDestination::Bolt11 {
11680 invoice: ans.invoice.cst_decode(),
11681 bip353_address: ans.bip353_address.cst_decode(),
11682 }
11683 }
11684 2 => {
11685 let ans = unsafe { self.kind.Bolt12 };
11686 crate::model::SendDestination::Bolt12 {
11687 offer: ans.offer.cst_decode(),
11688 receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11689 bip353_address: ans.bip353_address.cst_decode(),
11690 }
11691 }
11692 _ => unreachable!(),
11693 }
11694 }
11695 }
11696 impl CstDecode<crate::model::SendPaymentRequest> for wire_cst_send_payment_request {
11697 fn cst_decode(self) -> crate::model::SendPaymentRequest {
11699 crate::model::SendPaymentRequest {
11700 prepare_response: self.prepare_response.cst_decode(),
11701 use_asset_fees: self.use_asset_fees.cst_decode(),
11702 payer_note: self.payer_note.cst_decode(),
11703 }
11704 }
11705 }
11706 impl CstDecode<crate::model::SendPaymentResponse> for wire_cst_send_payment_response {
11707 fn cst_decode(self) -> crate::model::SendPaymentResponse {
11709 crate::model::SendPaymentResponse {
11710 payment: self.payment.cst_decode(),
11711 }
11712 }
11713 }
11714 impl CstDecode<crate::model::SignMessageRequest> for wire_cst_sign_message_request {
11715 fn cst_decode(self) -> crate::model::SignMessageRequest {
11717 crate::model::SignMessageRequest {
11718 message: self.message.cst_decode(),
11719 }
11720 }
11721 }
11722 impl CstDecode<crate::model::SignMessageResponse> for wire_cst_sign_message_response {
11723 fn cst_decode(self) -> crate::model::SignMessageResponse {
11725 crate::model::SignMessageResponse {
11726 signature: self.signature.cst_decode(),
11727 }
11728 }
11729 }
11730 impl CstDecode<crate::bindings::SuccessAction> for wire_cst_success_action {
11731 fn cst_decode(self) -> crate::bindings::SuccessAction {
11733 match self.tag {
11734 0 => {
11735 let ans = unsafe { self.kind.Aes };
11736 crate::bindings::SuccessAction::Aes {
11737 data: ans.data.cst_decode(),
11738 }
11739 }
11740 1 => {
11741 let ans = unsafe { self.kind.Message };
11742 crate::bindings::SuccessAction::Message {
11743 data: ans.data.cst_decode(),
11744 }
11745 }
11746 2 => {
11747 let ans = unsafe { self.kind.Url };
11748 crate::bindings::SuccessAction::Url {
11749 data: ans.data.cst_decode(),
11750 }
11751 }
11752 _ => unreachable!(),
11753 }
11754 }
11755 }
11756 impl CstDecode<crate::bindings::SuccessActionProcessed> for wire_cst_success_action_processed {
11757 fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
11759 match self.tag {
11760 0 => {
11761 let ans = unsafe { self.kind.Aes };
11762 crate::bindings::SuccessActionProcessed::Aes {
11763 result: ans.result.cst_decode(),
11764 }
11765 }
11766 1 => {
11767 let ans = unsafe { self.kind.Message };
11768 crate::bindings::SuccessActionProcessed::Message {
11769 data: ans.data.cst_decode(),
11770 }
11771 }
11772 2 => {
11773 let ans = unsafe { self.kind.Url };
11774 crate::bindings::SuccessActionProcessed::Url {
11775 data: ans.data.cst_decode(),
11776 }
11777 }
11778 _ => unreachable!(),
11779 }
11780 }
11781 }
11782 impl CstDecode<crate::bindings::Symbol> for wire_cst_symbol {
11783 fn cst_decode(self) -> crate::bindings::Symbol {
11785 crate::bindings::Symbol {
11786 grapheme: self.grapheme.cst_decode(),
11787 template: self.template.cst_decode(),
11788 rtl: self.rtl.cst_decode(),
11789 position: self.position.cst_decode(),
11790 }
11791 }
11792 }
11793 impl CstDecode<crate::bindings::UrlSuccessActionData> for wire_cst_url_success_action_data {
11794 fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
11796 crate::bindings::UrlSuccessActionData {
11797 description: self.description.cst_decode(),
11798 url: self.url.cst_decode(),
11799 matches_callback_domain: self.matches_callback_domain.cst_decode(),
11800 }
11801 }
11802 }
11803 impl CstDecode<crate::model::WalletInfo> for wire_cst_wallet_info {
11804 fn cst_decode(self) -> crate::model::WalletInfo {
11806 crate::model::WalletInfo {
11807 balance_sat: self.balance_sat.cst_decode(),
11808 pending_send_sat: self.pending_send_sat.cst_decode(),
11809 pending_receive_sat: self.pending_receive_sat.cst_decode(),
11810 fingerprint: self.fingerprint.cst_decode(),
11811 pubkey: self.pubkey.cst_decode(),
11812 asset_balances: self.asset_balances.cst_decode(),
11813 }
11814 }
11815 }
11816 impl NewWithNullPtr for wire_cst_accept_payment_proposed_fees_request {
11817 fn new_with_null_ptr() -> Self {
11818 Self {
11819 response: Default::default(),
11820 }
11821 }
11822 }
11823 impl Default for wire_cst_accept_payment_proposed_fees_request {
11824 fn default() -> Self {
11825 Self::new_with_null_ptr()
11826 }
11827 }
11828 impl NewWithNullPtr for wire_cst_aes_success_action_data {
11829 fn new_with_null_ptr() -> Self {
11830 Self {
11831 description: core::ptr::null_mut(),
11832 ciphertext: core::ptr::null_mut(),
11833 iv: core::ptr::null_mut(),
11834 }
11835 }
11836 }
11837 impl Default for wire_cst_aes_success_action_data {
11838 fn default() -> Self {
11839 Self::new_with_null_ptr()
11840 }
11841 }
11842 impl NewWithNullPtr for wire_cst_aes_success_action_data_decrypted {
11843 fn new_with_null_ptr() -> Self {
11844 Self {
11845 description: core::ptr::null_mut(),
11846 plaintext: core::ptr::null_mut(),
11847 }
11848 }
11849 }
11850 impl Default for wire_cst_aes_success_action_data_decrypted {
11851 fn default() -> Self {
11852 Self::new_with_null_ptr()
11853 }
11854 }
11855 impl NewWithNullPtr for wire_cst_aes_success_action_data_result {
11856 fn new_with_null_ptr() -> Self {
11857 Self {
11858 tag: -1,
11859 kind: AesSuccessActionDataResultKind { nil__: () },
11860 }
11861 }
11862 }
11863 impl Default for wire_cst_aes_success_action_data_result {
11864 fn default() -> Self {
11865 Self::new_with_null_ptr()
11866 }
11867 }
11868 impl NewWithNullPtr for wire_cst_amount {
11869 fn new_with_null_ptr() -> Self {
11870 Self {
11871 tag: -1,
11872 kind: AmountKind { nil__: () },
11873 }
11874 }
11875 }
11876 impl Default for wire_cst_amount {
11877 fn default() -> Self {
11878 Self::new_with_null_ptr()
11879 }
11880 }
11881 impl NewWithNullPtr for wire_cst_asset_balance {
11882 fn new_with_null_ptr() -> Self {
11883 Self {
11884 asset_id: core::ptr::null_mut(),
11885 balance_sat: Default::default(),
11886 name: core::ptr::null_mut(),
11887 ticker: core::ptr::null_mut(),
11888 balance: core::ptr::null_mut(),
11889 }
11890 }
11891 }
11892 impl Default for wire_cst_asset_balance {
11893 fn default() -> Self {
11894 Self::new_with_null_ptr()
11895 }
11896 }
11897 impl NewWithNullPtr for wire_cst_asset_info {
11898 fn new_with_null_ptr() -> Self {
11899 Self {
11900 name: core::ptr::null_mut(),
11901 ticker: core::ptr::null_mut(),
11902 amount: Default::default(),
11903 fees: core::ptr::null_mut(),
11904 }
11905 }
11906 }
11907 impl Default for wire_cst_asset_info {
11908 fn default() -> Self {
11909 Self::new_with_null_ptr()
11910 }
11911 }
11912 impl NewWithNullPtr for wire_cst_asset_metadata {
11913 fn new_with_null_ptr() -> Self {
11914 Self {
11915 asset_id: core::ptr::null_mut(),
11916 name: core::ptr::null_mut(),
11917 ticker: core::ptr::null_mut(),
11918 precision: Default::default(),
11919 fiat_id: core::ptr::null_mut(),
11920 }
11921 }
11922 }
11923 impl Default for wire_cst_asset_metadata {
11924 fn default() -> Self {
11925 Self::new_with_null_ptr()
11926 }
11927 }
11928 impl NewWithNullPtr for wire_cst_backup_request {
11929 fn new_with_null_ptr() -> Self {
11930 Self {
11931 backup_path: core::ptr::null_mut(),
11932 }
11933 }
11934 }
11935 impl Default for wire_cst_backup_request {
11936 fn default() -> Self {
11937 Self::new_with_null_ptr()
11938 }
11939 }
11940 impl NewWithNullPtr for wire_cst_binding_event_listener {
11941 fn new_with_null_ptr() -> Self {
11942 Self {
11943 stream: core::ptr::null_mut(),
11944 }
11945 }
11946 }
11947 impl Default for wire_cst_binding_event_listener {
11948 fn default() -> Self {
11949 Self::new_with_null_ptr()
11950 }
11951 }
11952 impl NewWithNullPtr for wire_cst_bitcoin_address_data {
11953 fn new_with_null_ptr() -> Self {
11954 Self {
11955 address: core::ptr::null_mut(),
11956 network: Default::default(),
11957 amount_sat: core::ptr::null_mut(),
11958 label: core::ptr::null_mut(),
11959 message: core::ptr::null_mut(),
11960 }
11961 }
11962 }
11963 impl Default for wire_cst_bitcoin_address_data {
11964 fn default() -> Self {
11965 Self::new_with_null_ptr()
11966 }
11967 }
11968 impl NewWithNullPtr for wire_cst_blockchain_explorer {
11969 fn new_with_null_ptr() -> Self {
11970 Self {
11971 tag: -1,
11972 kind: BlockchainExplorerKind { nil__: () },
11973 }
11974 }
11975 }
11976 impl Default for wire_cst_blockchain_explorer {
11977 fn default() -> Self {
11978 Self::new_with_null_ptr()
11979 }
11980 }
11981 impl NewWithNullPtr for wire_cst_blockchain_info {
11982 fn new_with_null_ptr() -> Self {
11983 Self {
11984 liquid_tip: Default::default(),
11985 bitcoin_tip: Default::default(),
11986 }
11987 }
11988 }
11989 impl Default for wire_cst_blockchain_info {
11990 fn default() -> Self {
11991 Self::new_with_null_ptr()
11992 }
11993 }
11994 impl NewWithNullPtr for wire_cst_buy_bitcoin_request {
11995 fn new_with_null_ptr() -> Self {
11996 Self {
11997 prepare_response: Default::default(),
11998 redirect_url: core::ptr::null_mut(),
11999 }
12000 }
12001 }
12002 impl Default for wire_cst_buy_bitcoin_request {
12003 fn default() -> Self {
12004 Self::new_with_null_ptr()
12005 }
12006 }
12007 impl NewWithNullPtr for wire_cst_check_message_request {
12008 fn new_with_null_ptr() -> Self {
12009 Self {
12010 message: core::ptr::null_mut(),
12011 pubkey: core::ptr::null_mut(),
12012 signature: core::ptr::null_mut(),
12013 }
12014 }
12015 }
12016 impl Default for wire_cst_check_message_request {
12017 fn default() -> Self {
12018 Self::new_with_null_ptr()
12019 }
12020 }
12021 impl NewWithNullPtr for wire_cst_check_message_response {
12022 fn new_with_null_ptr() -> Self {
12023 Self {
12024 is_valid: Default::default(),
12025 }
12026 }
12027 }
12028 impl Default for wire_cst_check_message_response {
12029 fn default() -> Self {
12030 Self::new_with_null_ptr()
12031 }
12032 }
12033 impl NewWithNullPtr for wire_cst_config {
12034 fn new_with_null_ptr() -> Self {
12035 Self {
12036 liquid_explorer: Default::default(),
12037 bitcoin_explorer: Default::default(),
12038 working_dir: core::ptr::null_mut(),
12039 network: Default::default(),
12040 payment_timeout_sec: Default::default(),
12041 sync_service_url: core::ptr::null_mut(),
12042 zero_conf_max_amount_sat: core::ptr::null_mut(),
12043 breez_api_key: core::ptr::null_mut(),
12044 external_input_parsers: core::ptr::null_mut(),
12045 use_default_external_input_parsers: Default::default(),
12046 onchain_fee_rate_leeway_sat: core::ptr::null_mut(),
12047 asset_metadata: core::ptr::null_mut(),
12048 sideswap_api_key: core::ptr::null_mut(),
12049 use_magic_routing_hints: Default::default(),
12050 }
12051 }
12052 }
12053 impl Default for wire_cst_config {
12054 fn default() -> Self {
12055 Self::new_with_null_ptr()
12056 }
12057 }
12058 impl NewWithNullPtr for wire_cst_connect_request {
12059 fn new_with_null_ptr() -> Self {
12060 Self {
12061 config: Default::default(),
12062 mnemonic: core::ptr::null_mut(),
12063 passphrase: core::ptr::null_mut(),
12064 seed: core::ptr::null_mut(),
12065 }
12066 }
12067 }
12068 impl Default for wire_cst_connect_request {
12069 fn default() -> Self {
12070 Self::new_with_null_ptr()
12071 }
12072 }
12073 impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_request {
12074 fn new_with_null_ptr() -> Self {
12075 Self {
12076 offer: core::ptr::null_mut(),
12077 invoice_request: core::ptr::null_mut(),
12078 }
12079 }
12080 }
12081 impl Default for wire_cst_create_bolt_12_invoice_request {
12082 fn default() -> Self {
12083 Self::new_with_null_ptr()
12084 }
12085 }
12086 impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_response {
12087 fn new_with_null_ptr() -> Self {
12088 Self {
12089 invoice: core::ptr::null_mut(),
12090 }
12091 }
12092 }
12093 impl Default for wire_cst_create_bolt_12_invoice_response {
12094 fn default() -> Self {
12095 Self::new_with_null_ptr()
12096 }
12097 }
12098 impl NewWithNullPtr for wire_cst_currency_info {
12099 fn new_with_null_ptr() -> Self {
12100 Self {
12101 name: core::ptr::null_mut(),
12102 fraction_size: Default::default(),
12103 spacing: core::ptr::null_mut(),
12104 symbol: core::ptr::null_mut(),
12105 uniq_symbol: core::ptr::null_mut(),
12106 localized_name: core::ptr::null_mut(),
12107 locale_overrides: core::ptr::null_mut(),
12108 }
12109 }
12110 }
12111 impl Default for wire_cst_currency_info {
12112 fn default() -> Self {
12113 Self::new_with_null_ptr()
12114 }
12115 }
12116 impl NewWithNullPtr for wire_cst_external_input_parser {
12117 fn new_with_null_ptr() -> Self {
12118 Self {
12119 provider_id: core::ptr::null_mut(),
12120 input_regex: core::ptr::null_mut(),
12121 parser_url: core::ptr::null_mut(),
12122 }
12123 }
12124 }
12125 impl Default for wire_cst_external_input_parser {
12126 fn default() -> Self {
12127 Self::new_with_null_ptr()
12128 }
12129 }
12130 impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_request {
12131 fn new_with_null_ptr() -> Self {
12132 Self {
12133 swap_id: core::ptr::null_mut(),
12134 }
12135 }
12136 }
12137 impl Default for wire_cst_fetch_payment_proposed_fees_request {
12138 fn default() -> Self {
12139 Self::new_with_null_ptr()
12140 }
12141 }
12142 impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_response {
12143 fn new_with_null_ptr() -> Self {
12144 Self {
12145 swap_id: core::ptr::null_mut(),
12146 fees_sat: Default::default(),
12147 payer_amount_sat: Default::default(),
12148 receiver_amount_sat: Default::default(),
12149 }
12150 }
12151 }
12152 impl Default for wire_cst_fetch_payment_proposed_fees_response {
12153 fn default() -> Self {
12154 Self::new_with_null_ptr()
12155 }
12156 }
12157 impl NewWithNullPtr for wire_cst_fiat_currency {
12158 fn new_with_null_ptr() -> Self {
12159 Self {
12160 id: core::ptr::null_mut(),
12161 info: Default::default(),
12162 }
12163 }
12164 }
12165 impl Default for wire_cst_fiat_currency {
12166 fn default() -> Self {
12167 Self::new_with_null_ptr()
12168 }
12169 }
12170 impl NewWithNullPtr for wire_cst_get_info_response {
12171 fn new_with_null_ptr() -> Self {
12172 Self {
12173 wallet_info: Default::default(),
12174 blockchain_info: Default::default(),
12175 }
12176 }
12177 }
12178 impl Default for wire_cst_get_info_response {
12179 fn default() -> Self {
12180 Self::new_with_null_ptr()
12181 }
12182 }
12183 impl NewWithNullPtr for wire_cst_get_payment_request {
12184 fn new_with_null_ptr() -> Self {
12185 Self {
12186 tag: -1,
12187 kind: GetPaymentRequestKind { nil__: () },
12188 }
12189 }
12190 }
12191 impl Default for wire_cst_get_payment_request {
12192 fn default() -> Self {
12193 Self::new_with_null_ptr()
12194 }
12195 }
12196 impl NewWithNullPtr for wire_cst_input_type {
12197 fn new_with_null_ptr() -> Self {
12198 Self {
12199 tag: -1,
12200 kind: InputTypeKind { nil__: () },
12201 }
12202 }
12203 }
12204 impl Default for wire_cst_input_type {
12205 fn default() -> Self {
12206 Self::new_with_null_ptr()
12207 }
12208 }
12209 impl NewWithNullPtr for wire_cst_lightning_payment_limits_response {
12210 fn new_with_null_ptr() -> Self {
12211 Self {
12212 send: Default::default(),
12213 receive: Default::default(),
12214 }
12215 }
12216 }
12217 impl Default for wire_cst_lightning_payment_limits_response {
12218 fn default() -> Self {
12219 Self::new_with_null_ptr()
12220 }
12221 }
12222 impl NewWithNullPtr for wire_cst_limits {
12223 fn new_with_null_ptr() -> Self {
12224 Self {
12225 min_sat: Default::default(),
12226 max_sat: Default::default(),
12227 max_zero_conf_sat: Default::default(),
12228 }
12229 }
12230 }
12231 impl Default for wire_cst_limits {
12232 fn default() -> Self {
12233 Self::new_with_null_ptr()
12234 }
12235 }
12236 impl NewWithNullPtr for wire_cst_liquid_address_data {
12237 fn new_with_null_ptr() -> Self {
12238 Self {
12239 address: core::ptr::null_mut(),
12240 network: Default::default(),
12241 asset_id: core::ptr::null_mut(),
12242 amount: core::ptr::null_mut(),
12243 amount_sat: core::ptr::null_mut(),
12244 label: core::ptr::null_mut(),
12245 message: core::ptr::null_mut(),
12246 }
12247 }
12248 }
12249 impl Default for wire_cst_liquid_address_data {
12250 fn default() -> Self {
12251 Self::new_with_null_ptr()
12252 }
12253 }
12254 impl NewWithNullPtr for wire_cst_list_payment_details {
12255 fn new_with_null_ptr() -> Self {
12256 Self {
12257 tag: -1,
12258 kind: ListPaymentDetailsKind { nil__: () },
12259 }
12260 }
12261 }
12262 impl Default for wire_cst_list_payment_details {
12263 fn default() -> Self {
12264 Self::new_with_null_ptr()
12265 }
12266 }
12267 impl NewWithNullPtr for wire_cst_list_payments_request {
12268 fn new_with_null_ptr() -> Self {
12269 Self {
12270 filters: core::ptr::null_mut(),
12271 states: core::ptr::null_mut(),
12272 from_timestamp: core::ptr::null_mut(),
12273 to_timestamp: core::ptr::null_mut(),
12274 offset: core::ptr::null_mut(),
12275 limit: core::ptr::null_mut(),
12276 details: core::ptr::null_mut(),
12277 sort_ascending: core::ptr::null_mut(),
12278 }
12279 }
12280 }
12281 impl Default for wire_cst_list_payments_request {
12282 fn default() -> Self {
12283 Self::new_with_null_ptr()
12284 }
12285 }
12286 impl NewWithNullPtr for wire_cst_ln_invoice {
12287 fn new_with_null_ptr() -> Self {
12288 Self {
12289 bolt11: core::ptr::null_mut(),
12290 network: Default::default(),
12291 payee_pubkey: core::ptr::null_mut(),
12292 payment_hash: core::ptr::null_mut(),
12293 description: core::ptr::null_mut(),
12294 description_hash: core::ptr::null_mut(),
12295 amount_msat: core::ptr::null_mut(),
12296 timestamp: Default::default(),
12297 expiry: Default::default(),
12298 routing_hints: core::ptr::null_mut(),
12299 payment_secret: core::ptr::null_mut(),
12300 min_final_cltv_expiry_delta: Default::default(),
12301 }
12302 }
12303 }
12304 impl Default for wire_cst_ln_invoice {
12305 fn default() -> Self {
12306 Self::new_with_null_ptr()
12307 }
12308 }
12309 impl NewWithNullPtr for wire_cst_ln_offer {
12310 fn new_with_null_ptr() -> Self {
12311 Self {
12312 offer: core::ptr::null_mut(),
12313 chains: core::ptr::null_mut(),
12314 min_amount: core::ptr::null_mut(),
12315 description: core::ptr::null_mut(),
12316 absolute_expiry: core::ptr::null_mut(),
12317 issuer: core::ptr::null_mut(),
12318 signing_pubkey: core::ptr::null_mut(),
12319 paths: core::ptr::null_mut(),
12320 }
12321 }
12322 }
12323 impl Default for wire_cst_ln_offer {
12324 fn default() -> Self {
12325 Self::new_with_null_ptr()
12326 }
12327 }
12328 impl NewWithNullPtr for wire_cst_ln_offer_blinded_path {
12329 fn new_with_null_ptr() -> Self {
12330 Self {
12331 blinded_hops: core::ptr::null_mut(),
12332 }
12333 }
12334 }
12335 impl Default for wire_cst_ln_offer_blinded_path {
12336 fn default() -> Self {
12337 Self::new_with_null_ptr()
12338 }
12339 }
12340 impl NewWithNullPtr for wire_cst_ln_url_auth_error {
12341 fn new_with_null_ptr() -> Self {
12342 Self {
12343 tag: -1,
12344 kind: LnUrlAuthErrorKind { nil__: () },
12345 }
12346 }
12347 }
12348 impl Default for wire_cst_ln_url_auth_error {
12349 fn default() -> Self {
12350 Self::new_with_null_ptr()
12351 }
12352 }
12353 impl NewWithNullPtr for wire_cst_ln_url_auth_request_data {
12354 fn new_with_null_ptr() -> Self {
12355 Self {
12356 k1: core::ptr::null_mut(),
12357 action: core::ptr::null_mut(),
12358 domain: core::ptr::null_mut(),
12359 url: core::ptr::null_mut(),
12360 }
12361 }
12362 }
12363 impl Default for wire_cst_ln_url_auth_request_data {
12364 fn default() -> Self {
12365 Self::new_with_null_ptr()
12366 }
12367 }
12368 impl NewWithNullPtr for wire_cst_ln_url_callback_status {
12369 fn new_with_null_ptr() -> Self {
12370 Self {
12371 tag: -1,
12372 kind: LnUrlCallbackStatusKind { nil__: () },
12373 }
12374 }
12375 }
12376 impl Default for wire_cst_ln_url_callback_status {
12377 fn default() -> Self {
12378 Self::new_with_null_ptr()
12379 }
12380 }
12381 impl NewWithNullPtr for wire_cst_ln_url_error_data {
12382 fn new_with_null_ptr() -> Self {
12383 Self {
12384 reason: core::ptr::null_mut(),
12385 }
12386 }
12387 }
12388 impl Default for wire_cst_ln_url_error_data {
12389 fn default() -> Self {
12390 Self::new_with_null_ptr()
12391 }
12392 }
12393 impl NewWithNullPtr for wire_cst_ln_url_info {
12394 fn new_with_null_ptr() -> Self {
12395 Self {
12396 ln_address: core::ptr::null_mut(),
12397 lnurl_pay_comment: core::ptr::null_mut(),
12398 lnurl_pay_domain: core::ptr::null_mut(),
12399 lnurl_pay_metadata: core::ptr::null_mut(),
12400 lnurl_pay_success_action: core::ptr::null_mut(),
12401 lnurl_pay_unprocessed_success_action: core::ptr::null_mut(),
12402 lnurl_withdraw_endpoint: core::ptr::null_mut(),
12403 }
12404 }
12405 }
12406 impl Default for wire_cst_ln_url_info {
12407 fn default() -> Self {
12408 Self::new_with_null_ptr()
12409 }
12410 }
12411 impl NewWithNullPtr for wire_cst_ln_url_pay_error {
12412 fn new_with_null_ptr() -> Self {
12413 Self {
12414 tag: -1,
12415 kind: LnUrlPayErrorKind { nil__: () },
12416 }
12417 }
12418 }
12419 impl Default for wire_cst_ln_url_pay_error {
12420 fn default() -> Self {
12421 Self::new_with_null_ptr()
12422 }
12423 }
12424 impl NewWithNullPtr for wire_cst_ln_url_pay_error_data {
12425 fn new_with_null_ptr() -> Self {
12426 Self {
12427 payment_hash: core::ptr::null_mut(),
12428 reason: core::ptr::null_mut(),
12429 }
12430 }
12431 }
12432 impl Default for wire_cst_ln_url_pay_error_data {
12433 fn default() -> Self {
12434 Self::new_with_null_ptr()
12435 }
12436 }
12437 impl NewWithNullPtr for wire_cst_ln_url_pay_request {
12438 fn new_with_null_ptr() -> Self {
12439 Self {
12440 prepare_response: Default::default(),
12441 }
12442 }
12443 }
12444 impl Default for wire_cst_ln_url_pay_request {
12445 fn default() -> Self {
12446 Self::new_with_null_ptr()
12447 }
12448 }
12449 impl NewWithNullPtr for wire_cst_ln_url_pay_request_data {
12450 fn new_with_null_ptr() -> Self {
12451 Self {
12452 callback: core::ptr::null_mut(),
12453 min_sendable: Default::default(),
12454 max_sendable: Default::default(),
12455 metadata_str: core::ptr::null_mut(),
12456 comment_allowed: Default::default(),
12457 domain: core::ptr::null_mut(),
12458 allows_nostr: Default::default(),
12459 nostr_pubkey: core::ptr::null_mut(),
12460 ln_address: core::ptr::null_mut(),
12461 }
12462 }
12463 }
12464 impl Default for wire_cst_ln_url_pay_request_data {
12465 fn default() -> Self {
12466 Self::new_with_null_ptr()
12467 }
12468 }
12469 impl NewWithNullPtr for wire_cst_ln_url_pay_result {
12470 fn new_with_null_ptr() -> Self {
12471 Self {
12472 tag: -1,
12473 kind: LnUrlPayResultKind { nil__: () },
12474 }
12475 }
12476 }
12477 impl Default for wire_cst_ln_url_pay_result {
12478 fn default() -> Self {
12479 Self::new_with_null_ptr()
12480 }
12481 }
12482 impl NewWithNullPtr for wire_cst_ln_url_pay_success_data {
12483 fn new_with_null_ptr() -> Self {
12484 Self {
12485 payment: Default::default(),
12486 success_action: core::ptr::null_mut(),
12487 }
12488 }
12489 }
12490 impl Default for wire_cst_ln_url_pay_success_data {
12491 fn default() -> Self {
12492 Self::new_with_null_ptr()
12493 }
12494 }
12495 impl NewWithNullPtr for wire_cst_ln_url_withdraw_error {
12496 fn new_with_null_ptr() -> Self {
12497 Self {
12498 tag: -1,
12499 kind: LnUrlWithdrawErrorKind { nil__: () },
12500 }
12501 }
12502 }
12503 impl Default for wire_cst_ln_url_withdraw_error {
12504 fn default() -> Self {
12505 Self::new_with_null_ptr()
12506 }
12507 }
12508 impl NewWithNullPtr for wire_cst_ln_url_withdraw_request {
12509 fn new_with_null_ptr() -> Self {
12510 Self {
12511 data: Default::default(),
12512 amount_msat: Default::default(),
12513 description: core::ptr::null_mut(),
12514 }
12515 }
12516 }
12517 impl Default for wire_cst_ln_url_withdraw_request {
12518 fn default() -> Self {
12519 Self::new_with_null_ptr()
12520 }
12521 }
12522 impl NewWithNullPtr for wire_cst_ln_url_withdraw_request_data {
12523 fn new_with_null_ptr() -> Self {
12524 Self {
12525 callback: core::ptr::null_mut(),
12526 k1: core::ptr::null_mut(),
12527 default_description: core::ptr::null_mut(),
12528 min_withdrawable: Default::default(),
12529 max_withdrawable: Default::default(),
12530 }
12531 }
12532 }
12533 impl Default for wire_cst_ln_url_withdraw_request_data {
12534 fn default() -> Self {
12535 Self::new_with_null_ptr()
12536 }
12537 }
12538 impl NewWithNullPtr for wire_cst_ln_url_withdraw_result {
12539 fn new_with_null_ptr() -> Self {
12540 Self {
12541 tag: -1,
12542 kind: LnUrlWithdrawResultKind { nil__: () },
12543 }
12544 }
12545 }
12546 impl Default for wire_cst_ln_url_withdraw_result {
12547 fn default() -> Self {
12548 Self::new_with_null_ptr()
12549 }
12550 }
12551 impl NewWithNullPtr for wire_cst_ln_url_withdraw_success_data {
12552 fn new_with_null_ptr() -> Self {
12553 Self {
12554 invoice: Default::default(),
12555 }
12556 }
12557 }
12558 impl Default for wire_cst_ln_url_withdraw_success_data {
12559 fn default() -> Self {
12560 Self::new_with_null_ptr()
12561 }
12562 }
12563 impl NewWithNullPtr for wire_cst_locale_overrides {
12564 fn new_with_null_ptr() -> Self {
12565 Self {
12566 locale: core::ptr::null_mut(),
12567 spacing: core::ptr::null_mut(),
12568 symbol: Default::default(),
12569 }
12570 }
12571 }
12572 impl Default for wire_cst_locale_overrides {
12573 fn default() -> Self {
12574 Self::new_with_null_ptr()
12575 }
12576 }
12577 impl NewWithNullPtr for wire_cst_localized_name {
12578 fn new_with_null_ptr() -> Self {
12579 Self {
12580 locale: core::ptr::null_mut(),
12581 name: core::ptr::null_mut(),
12582 }
12583 }
12584 }
12585 impl Default for wire_cst_localized_name {
12586 fn default() -> Self {
12587 Self::new_with_null_ptr()
12588 }
12589 }
12590 impl NewWithNullPtr for wire_cst_log_entry {
12591 fn new_with_null_ptr() -> Self {
12592 Self {
12593 line: core::ptr::null_mut(),
12594 level: core::ptr::null_mut(),
12595 }
12596 }
12597 }
12598 impl Default for wire_cst_log_entry {
12599 fn default() -> Self {
12600 Self::new_with_null_ptr()
12601 }
12602 }
12603 impl NewWithNullPtr for wire_cst_message_success_action_data {
12604 fn new_with_null_ptr() -> Self {
12605 Self {
12606 message: core::ptr::null_mut(),
12607 }
12608 }
12609 }
12610 impl Default for wire_cst_message_success_action_data {
12611 fn default() -> Self {
12612 Self::new_with_null_ptr()
12613 }
12614 }
12615 impl NewWithNullPtr for wire_cst_onchain_payment_limits_response {
12616 fn new_with_null_ptr() -> Self {
12617 Self {
12618 send: Default::default(),
12619 receive: Default::default(),
12620 }
12621 }
12622 }
12623 impl Default for wire_cst_onchain_payment_limits_response {
12624 fn default() -> Self {
12625 Self::new_with_null_ptr()
12626 }
12627 }
12628 impl NewWithNullPtr for wire_cst_pay_amount {
12629 fn new_with_null_ptr() -> Self {
12630 Self {
12631 tag: -1,
12632 kind: PayAmountKind { nil__: () },
12633 }
12634 }
12635 }
12636 impl Default for wire_cst_pay_amount {
12637 fn default() -> Self {
12638 Self::new_with_null_ptr()
12639 }
12640 }
12641 impl NewWithNullPtr for wire_cst_pay_onchain_request {
12642 fn new_with_null_ptr() -> Self {
12643 Self {
12644 address: core::ptr::null_mut(),
12645 prepare_response: Default::default(),
12646 }
12647 }
12648 }
12649 impl Default for wire_cst_pay_onchain_request {
12650 fn default() -> Self {
12651 Self::new_with_null_ptr()
12652 }
12653 }
12654 impl NewWithNullPtr for wire_cst_payment {
12655 fn new_with_null_ptr() -> Self {
12656 Self {
12657 destination: core::ptr::null_mut(),
12658 tx_id: core::ptr::null_mut(),
12659 unblinding_data: core::ptr::null_mut(),
12660 timestamp: Default::default(),
12661 amount_sat: Default::default(),
12662 fees_sat: Default::default(),
12663 swapper_fees_sat: core::ptr::null_mut(),
12664 payment_type: Default::default(),
12665 status: Default::default(),
12666 details: Default::default(),
12667 }
12668 }
12669 }
12670 impl Default for wire_cst_payment {
12671 fn default() -> Self {
12672 Self::new_with_null_ptr()
12673 }
12674 }
12675 impl NewWithNullPtr for wire_cst_payment_details {
12676 fn new_with_null_ptr() -> Self {
12677 Self {
12678 tag: -1,
12679 kind: PaymentDetailsKind { nil__: () },
12680 }
12681 }
12682 }
12683 impl Default for wire_cst_payment_details {
12684 fn default() -> Self {
12685 Self::new_with_null_ptr()
12686 }
12687 }
12688 impl NewWithNullPtr for wire_cst_payment_error {
12689 fn new_with_null_ptr() -> Self {
12690 Self {
12691 tag: -1,
12692 kind: PaymentErrorKind { nil__: () },
12693 }
12694 }
12695 }
12696 impl Default for wire_cst_payment_error {
12697 fn default() -> Self {
12698 Self::new_with_null_ptr()
12699 }
12700 }
12701 impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_request {
12702 fn new_with_null_ptr() -> Self {
12703 Self {
12704 provider: Default::default(),
12705 amount_sat: Default::default(),
12706 }
12707 }
12708 }
12709 impl Default for wire_cst_prepare_buy_bitcoin_request {
12710 fn default() -> Self {
12711 Self::new_with_null_ptr()
12712 }
12713 }
12714 impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_response {
12715 fn new_with_null_ptr() -> Self {
12716 Self {
12717 provider: Default::default(),
12718 amount_sat: Default::default(),
12719 fees_sat: Default::default(),
12720 }
12721 }
12722 }
12723 impl Default for wire_cst_prepare_buy_bitcoin_response {
12724 fn default() -> Self {
12725 Self::new_with_null_ptr()
12726 }
12727 }
12728 impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_request {
12729 fn new_with_null_ptr() -> Self {
12730 Self {
12731 data: Default::default(),
12732 amount: Default::default(),
12733 bip353_address: core::ptr::null_mut(),
12734 comment: core::ptr::null_mut(),
12735 validate_success_action_url: core::ptr::null_mut(),
12736 }
12737 }
12738 }
12739 impl Default for wire_cst_prepare_ln_url_pay_request {
12740 fn default() -> Self {
12741 Self::new_with_null_ptr()
12742 }
12743 }
12744 impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_response {
12745 fn new_with_null_ptr() -> Self {
12746 Self {
12747 destination: Default::default(),
12748 fees_sat: Default::default(),
12749 data: Default::default(),
12750 amount: Default::default(),
12751 comment: core::ptr::null_mut(),
12752 success_action: core::ptr::null_mut(),
12753 }
12754 }
12755 }
12756 impl Default for wire_cst_prepare_ln_url_pay_response {
12757 fn default() -> Self {
12758 Self::new_with_null_ptr()
12759 }
12760 }
12761 impl NewWithNullPtr for wire_cst_prepare_pay_onchain_request {
12762 fn new_with_null_ptr() -> Self {
12763 Self {
12764 amount: Default::default(),
12765 fee_rate_sat_per_vbyte: core::ptr::null_mut(),
12766 }
12767 }
12768 }
12769 impl Default for wire_cst_prepare_pay_onchain_request {
12770 fn default() -> Self {
12771 Self::new_with_null_ptr()
12772 }
12773 }
12774 impl NewWithNullPtr for wire_cst_prepare_pay_onchain_response {
12775 fn new_with_null_ptr() -> Self {
12776 Self {
12777 receiver_amount_sat: Default::default(),
12778 claim_fees_sat: Default::default(),
12779 total_fees_sat: Default::default(),
12780 }
12781 }
12782 }
12783 impl Default for wire_cst_prepare_pay_onchain_response {
12784 fn default() -> Self {
12785 Self::new_with_null_ptr()
12786 }
12787 }
12788 impl NewWithNullPtr for wire_cst_prepare_receive_request {
12789 fn new_with_null_ptr() -> Self {
12790 Self {
12791 payment_method: Default::default(),
12792 amount: core::ptr::null_mut(),
12793 }
12794 }
12795 }
12796 impl Default for wire_cst_prepare_receive_request {
12797 fn default() -> Self {
12798 Self::new_with_null_ptr()
12799 }
12800 }
12801 impl NewWithNullPtr for wire_cst_prepare_receive_response {
12802 fn new_with_null_ptr() -> Self {
12803 Self {
12804 payment_method: Default::default(),
12805 fees_sat: Default::default(),
12806 amount: core::ptr::null_mut(),
12807 min_payer_amount_sat: core::ptr::null_mut(),
12808 max_payer_amount_sat: core::ptr::null_mut(),
12809 swapper_feerate: core::ptr::null_mut(),
12810 }
12811 }
12812 }
12813 impl Default for wire_cst_prepare_receive_response {
12814 fn default() -> Self {
12815 Self::new_with_null_ptr()
12816 }
12817 }
12818 impl NewWithNullPtr for wire_cst_prepare_refund_request {
12819 fn new_with_null_ptr() -> Self {
12820 Self {
12821 swap_address: core::ptr::null_mut(),
12822 refund_address: core::ptr::null_mut(),
12823 fee_rate_sat_per_vbyte: Default::default(),
12824 }
12825 }
12826 }
12827 impl Default for wire_cst_prepare_refund_request {
12828 fn default() -> Self {
12829 Self::new_with_null_ptr()
12830 }
12831 }
12832 impl NewWithNullPtr for wire_cst_prepare_refund_response {
12833 fn new_with_null_ptr() -> Self {
12834 Self {
12835 tx_vsize: Default::default(),
12836 tx_fee_sat: Default::default(),
12837 last_refund_tx_id: core::ptr::null_mut(),
12838 }
12839 }
12840 }
12841 impl Default for wire_cst_prepare_refund_response {
12842 fn default() -> Self {
12843 Self::new_with_null_ptr()
12844 }
12845 }
12846 impl NewWithNullPtr for wire_cst_prepare_send_request {
12847 fn new_with_null_ptr() -> Self {
12848 Self {
12849 destination: core::ptr::null_mut(),
12850 amount: core::ptr::null_mut(),
12851 }
12852 }
12853 }
12854 impl Default for wire_cst_prepare_send_request {
12855 fn default() -> Self {
12856 Self::new_with_null_ptr()
12857 }
12858 }
12859 impl NewWithNullPtr for wire_cst_prepare_send_response {
12860 fn new_with_null_ptr() -> Self {
12861 Self {
12862 destination: Default::default(),
12863 amount: core::ptr::null_mut(),
12864 fees_sat: core::ptr::null_mut(),
12865 estimated_asset_fees: core::ptr::null_mut(),
12866 exchange_amount_sat: core::ptr::null_mut(),
12867 }
12868 }
12869 }
12870 impl Default for wire_cst_prepare_send_response {
12871 fn default() -> Self {
12872 Self::new_with_null_ptr()
12873 }
12874 }
12875 impl NewWithNullPtr for wire_cst_rate {
12876 fn new_with_null_ptr() -> Self {
12877 Self {
12878 coin: core::ptr::null_mut(),
12879 value: Default::default(),
12880 }
12881 }
12882 }
12883 impl Default for wire_cst_rate {
12884 fn default() -> Self {
12885 Self::new_with_null_ptr()
12886 }
12887 }
12888 impl NewWithNullPtr for wire_cst_receive_amount {
12889 fn new_with_null_ptr() -> Self {
12890 Self {
12891 tag: -1,
12892 kind: ReceiveAmountKind { nil__: () },
12893 }
12894 }
12895 }
12896 impl Default for wire_cst_receive_amount {
12897 fn default() -> Self {
12898 Self::new_with_null_ptr()
12899 }
12900 }
12901 impl NewWithNullPtr for wire_cst_receive_payment_request {
12902 fn new_with_null_ptr() -> Self {
12903 Self {
12904 prepare_response: Default::default(),
12905 description: core::ptr::null_mut(),
12906 use_description_hash: core::ptr::null_mut(),
12907 payer_note: core::ptr::null_mut(),
12908 }
12909 }
12910 }
12911 impl Default for wire_cst_receive_payment_request {
12912 fn default() -> Self {
12913 Self::new_with_null_ptr()
12914 }
12915 }
12916 impl NewWithNullPtr for wire_cst_receive_payment_response {
12917 fn new_with_null_ptr() -> Self {
12918 Self {
12919 destination: core::ptr::null_mut(),
12920 }
12921 }
12922 }
12923 impl Default for wire_cst_receive_payment_response {
12924 fn default() -> Self {
12925 Self::new_with_null_ptr()
12926 }
12927 }
12928 impl NewWithNullPtr for wire_cst_recommended_fees {
12929 fn new_with_null_ptr() -> Self {
12930 Self {
12931 fastest_fee: Default::default(),
12932 half_hour_fee: Default::default(),
12933 hour_fee: Default::default(),
12934 economy_fee: Default::default(),
12935 minimum_fee: Default::default(),
12936 }
12937 }
12938 }
12939 impl Default for wire_cst_recommended_fees {
12940 fn default() -> Self {
12941 Self::new_with_null_ptr()
12942 }
12943 }
12944 impl NewWithNullPtr for wire_cst_refund_request {
12945 fn new_with_null_ptr() -> Self {
12946 Self {
12947 swap_address: core::ptr::null_mut(),
12948 refund_address: core::ptr::null_mut(),
12949 fee_rate_sat_per_vbyte: Default::default(),
12950 }
12951 }
12952 }
12953 impl Default for wire_cst_refund_request {
12954 fn default() -> Self {
12955 Self::new_with_null_ptr()
12956 }
12957 }
12958 impl NewWithNullPtr for wire_cst_refund_response {
12959 fn new_with_null_ptr() -> Self {
12960 Self {
12961 refund_tx_id: core::ptr::null_mut(),
12962 }
12963 }
12964 }
12965 impl Default for wire_cst_refund_response {
12966 fn default() -> Self {
12967 Self::new_with_null_ptr()
12968 }
12969 }
12970 impl NewWithNullPtr for wire_cst_refundable_swap {
12971 fn new_with_null_ptr() -> Self {
12972 Self {
12973 swap_address: core::ptr::null_mut(),
12974 timestamp: Default::default(),
12975 amount_sat: Default::default(),
12976 last_refund_tx_id: core::ptr::null_mut(),
12977 }
12978 }
12979 }
12980 impl Default for wire_cst_refundable_swap {
12981 fn default() -> Self {
12982 Self::new_with_null_ptr()
12983 }
12984 }
12985 impl NewWithNullPtr for wire_cst_restore_request {
12986 fn new_with_null_ptr() -> Self {
12987 Self {
12988 backup_path: core::ptr::null_mut(),
12989 }
12990 }
12991 }
12992 impl Default for wire_cst_restore_request {
12993 fn default() -> Self {
12994 Self::new_with_null_ptr()
12995 }
12996 }
12997 impl NewWithNullPtr for wire_cst_route_hint {
12998 fn new_with_null_ptr() -> Self {
12999 Self {
13000 hops: core::ptr::null_mut(),
13001 }
13002 }
13003 }
13004 impl Default for wire_cst_route_hint {
13005 fn default() -> Self {
13006 Self::new_with_null_ptr()
13007 }
13008 }
13009 impl NewWithNullPtr for wire_cst_route_hint_hop {
13010 fn new_with_null_ptr() -> Self {
13011 Self {
13012 src_node_id: core::ptr::null_mut(),
13013 short_channel_id: core::ptr::null_mut(),
13014 fees_base_msat: Default::default(),
13015 fees_proportional_millionths: Default::default(),
13016 cltv_expiry_delta: Default::default(),
13017 htlc_minimum_msat: core::ptr::null_mut(),
13018 htlc_maximum_msat: core::ptr::null_mut(),
13019 }
13020 }
13021 }
13022 impl Default for wire_cst_route_hint_hop {
13023 fn default() -> Self {
13024 Self::new_with_null_ptr()
13025 }
13026 }
13027 impl NewWithNullPtr for wire_cst_sdk_error {
13028 fn new_with_null_ptr() -> Self {
13029 Self {
13030 tag: -1,
13031 kind: SdkErrorKind { nil__: () },
13032 }
13033 }
13034 }
13035 impl Default for wire_cst_sdk_error {
13036 fn default() -> Self {
13037 Self::new_with_null_ptr()
13038 }
13039 }
13040 impl NewWithNullPtr for wire_cst_sdk_event {
13041 fn new_with_null_ptr() -> Self {
13042 Self {
13043 tag: -1,
13044 kind: SdkEventKind { nil__: () },
13045 }
13046 }
13047 }
13048 impl Default for wire_cst_sdk_event {
13049 fn default() -> Self {
13050 Self::new_with_null_ptr()
13051 }
13052 }
13053 impl NewWithNullPtr for wire_cst_send_destination {
13054 fn new_with_null_ptr() -> Self {
13055 Self {
13056 tag: -1,
13057 kind: SendDestinationKind { nil__: () },
13058 }
13059 }
13060 }
13061 impl Default for wire_cst_send_destination {
13062 fn default() -> Self {
13063 Self::new_with_null_ptr()
13064 }
13065 }
13066 impl NewWithNullPtr for wire_cst_send_payment_request {
13067 fn new_with_null_ptr() -> Self {
13068 Self {
13069 prepare_response: Default::default(),
13070 use_asset_fees: core::ptr::null_mut(),
13071 payer_note: core::ptr::null_mut(),
13072 }
13073 }
13074 }
13075 impl Default for wire_cst_send_payment_request {
13076 fn default() -> Self {
13077 Self::new_with_null_ptr()
13078 }
13079 }
13080 impl NewWithNullPtr for wire_cst_send_payment_response {
13081 fn new_with_null_ptr() -> Self {
13082 Self {
13083 payment: Default::default(),
13084 }
13085 }
13086 }
13087 impl Default for wire_cst_send_payment_response {
13088 fn default() -> Self {
13089 Self::new_with_null_ptr()
13090 }
13091 }
13092 impl NewWithNullPtr for wire_cst_sign_message_request {
13093 fn new_with_null_ptr() -> Self {
13094 Self {
13095 message: core::ptr::null_mut(),
13096 }
13097 }
13098 }
13099 impl Default for wire_cst_sign_message_request {
13100 fn default() -> Self {
13101 Self::new_with_null_ptr()
13102 }
13103 }
13104 impl NewWithNullPtr for wire_cst_sign_message_response {
13105 fn new_with_null_ptr() -> Self {
13106 Self {
13107 signature: core::ptr::null_mut(),
13108 }
13109 }
13110 }
13111 impl Default for wire_cst_sign_message_response {
13112 fn default() -> Self {
13113 Self::new_with_null_ptr()
13114 }
13115 }
13116 impl NewWithNullPtr for wire_cst_success_action {
13117 fn new_with_null_ptr() -> Self {
13118 Self {
13119 tag: -1,
13120 kind: SuccessActionKind { nil__: () },
13121 }
13122 }
13123 }
13124 impl Default for wire_cst_success_action {
13125 fn default() -> Self {
13126 Self::new_with_null_ptr()
13127 }
13128 }
13129 impl NewWithNullPtr for wire_cst_success_action_processed {
13130 fn new_with_null_ptr() -> Self {
13131 Self {
13132 tag: -1,
13133 kind: SuccessActionProcessedKind { nil__: () },
13134 }
13135 }
13136 }
13137 impl Default for wire_cst_success_action_processed {
13138 fn default() -> Self {
13139 Self::new_with_null_ptr()
13140 }
13141 }
13142 impl NewWithNullPtr for wire_cst_symbol {
13143 fn new_with_null_ptr() -> Self {
13144 Self {
13145 grapheme: core::ptr::null_mut(),
13146 template: core::ptr::null_mut(),
13147 rtl: core::ptr::null_mut(),
13148 position: core::ptr::null_mut(),
13149 }
13150 }
13151 }
13152 impl Default for wire_cst_symbol {
13153 fn default() -> Self {
13154 Self::new_with_null_ptr()
13155 }
13156 }
13157 impl NewWithNullPtr for wire_cst_url_success_action_data {
13158 fn new_with_null_ptr() -> Self {
13159 Self {
13160 description: core::ptr::null_mut(),
13161 url: core::ptr::null_mut(),
13162 matches_callback_domain: Default::default(),
13163 }
13164 }
13165 }
13166 impl Default for wire_cst_url_success_action_data {
13167 fn default() -> Self {
13168 Self::new_with_null_ptr()
13169 }
13170 }
13171 impl NewWithNullPtr for wire_cst_wallet_info {
13172 fn new_with_null_ptr() -> Self {
13173 Self {
13174 balance_sat: Default::default(),
13175 pending_send_sat: Default::default(),
13176 pending_receive_sat: Default::default(),
13177 fingerprint: core::ptr::null_mut(),
13178 pubkey: core::ptr::null_mut(),
13179 asset_balances: core::ptr::null_mut(),
13180 }
13181 }
13182 }
13183 impl Default for wire_cst_wallet_info {
13184 fn default() -> Self {
13185 Self::new_with_null_ptr()
13186 }
13187 }
13188
13189 #[unsafe(no_mangle)]
13190 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees(
13191 port_: i64,
13192 that: usize,
13193 req: *mut wire_cst_accept_payment_proposed_fees_request,
13194 ) {
13195 wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(port_, that, req)
13196 }
13197
13198 #[unsafe(no_mangle)]
13199 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_add_event_listener(
13200 port_: i64,
13201 that: usize,
13202 listener: *mut wire_cst_list_prim_u_8_strict,
13203 ) {
13204 wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(port_, that, listener)
13205 }
13206
13207 #[unsafe(no_mangle)]
13208 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_backup(
13209 that: usize,
13210 req: *mut wire_cst_backup_request,
13211 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13212 wire__crate__bindings__BindingLiquidSdk_backup_impl(that, req)
13213 }
13214
13215 #[unsafe(no_mangle)]
13216 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_buy_bitcoin(
13217 port_: i64,
13218 that: usize,
13219 req: *mut wire_cst_buy_bitcoin_request,
13220 ) {
13221 wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(port_, that, req)
13222 }
13223
13224 #[unsafe(no_mangle)]
13225 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_check_message(
13226 that: usize,
13227 req: *mut wire_cst_check_message_request,
13228 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13229 wire__crate__bindings__BindingLiquidSdk_check_message_impl(that, req)
13230 }
13231
13232 #[unsafe(no_mangle)]
13233 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice(
13234 port_: i64,
13235 that: usize,
13236 req: *mut wire_cst_create_bolt_12_invoice_request,
13237 ) {
13238 wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(port_, that, req)
13239 }
13240
13241 #[unsafe(no_mangle)]
13242 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_disconnect(
13243 port_: i64,
13244 that: usize,
13245 ) {
13246 wire__crate__bindings__BindingLiquidSdk_disconnect_impl(port_, that)
13247 }
13248
13249 #[unsafe(no_mangle)]
13250 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache(
13251 that: usize,
13252 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13253 wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(that)
13254 }
13255
13256 #[unsafe(no_mangle)]
13257 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates(
13258 port_: i64,
13259 that: usize,
13260 ) {
13261 wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(port_, that)
13262 }
13263
13264 #[unsafe(no_mangle)]
13265 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
13266 port_: i64,
13267 that: usize,
13268 ) {
13269 wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(port_, that)
13270 }
13271
13272 #[unsafe(no_mangle)]
13273 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
13274 port_: i64,
13275 that: usize,
13276 ) {
13277 wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(port_, that)
13278 }
13279
13280 #[unsafe(no_mangle)]
13281 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees(
13282 port_: i64,
13283 that: usize,
13284 req: *mut wire_cst_fetch_payment_proposed_fees_request,
13285 ) {
13286 wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(port_, that, req)
13287 }
13288
13289 #[unsafe(no_mangle)]
13290 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info(
13291 port_: i64,
13292 that: usize,
13293 ) {
13294 wire__crate__bindings__BindingLiquidSdk_get_info_impl(port_, that)
13295 }
13296
13297 #[unsafe(no_mangle)]
13298 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_payment(
13299 port_: i64,
13300 that: usize,
13301 req: *mut wire_cst_get_payment_request,
13302 ) {
13303 wire__crate__bindings__BindingLiquidSdk_get_payment_impl(port_, that, req)
13304 }
13305
13306 #[unsafe(no_mangle)]
13307 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies(
13308 port_: i64,
13309 that: usize,
13310 ) {
13311 wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(port_, that)
13312 }
13313
13314 #[unsafe(no_mangle)]
13315 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_payments(
13316 port_: i64,
13317 that: usize,
13318 req: *mut wire_cst_list_payments_request,
13319 ) {
13320 wire__crate__bindings__BindingLiquidSdk_list_payments_impl(port_, that, req)
13321 }
13322
13323 #[unsafe(no_mangle)]
13324 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_refundables(
13325 port_: i64,
13326 that: usize,
13327 ) {
13328 wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(port_, that)
13329 }
13330
13331 #[unsafe(no_mangle)]
13332 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_auth(
13333 port_: i64,
13334 that: usize,
13335 req_data: *mut wire_cst_ln_url_auth_request_data,
13336 ) {
13337 wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(port_, that, req_data)
13338 }
13339
13340 #[unsafe(no_mangle)]
13341 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_pay(
13342 port_: i64,
13343 that: usize,
13344 req: *mut wire_cst_ln_url_pay_request,
13345 ) {
13346 wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(port_, that, req)
13347 }
13348
13349 #[unsafe(no_mangle)]
13350 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw(
13351 port_: i64,
13352 that: usize,
13353 req: *mut wire_cst_ln_url_withdraw_request,
13354 ) {
13355 wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(port_, that, req)
13356 }
13357
13358 #[unsafe(no_mangle)]
13359 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_parse(
13360 port_: i64,
13361 that: usize,
13362 input: *mut wire_cst_list_prim_u_8_strict,
13363 ) {
13364 wire__crate__bindings__BindingLiquidSdk_parse_impl(port_, that, input)
13365 }
13366
13367 #[unsafe(no_mangle)]
13368 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_pay_onchain(
13369 port_: i64,
13370 that: usize,
13371 req: *mut wire_cst_pay_onchain_request,
13372 ) {
13373 wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(port_, that, req)
13374 }
13375
13376 #[unsafe(no_mangle)]
13377 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin(
13378 port_: i64,
13379 that: usize,
13380 req: *mut wire_cst_prepare_buy_bitcoin_request,
13381 ) {
13382 wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(port_, that, req)
13383 }
13384
13385 #[unsafe(no_mangle)]
13386 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay(
13387 port_: i64,
13388 that: usize,
13389 req: *mut wire_cst_prepare_ln_url_pay_request,
13390 ) {
13391 wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(port_, that, req)
13392 }
13393
13394 #[unsafe(no_mangle)]
13395 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain(
13396 port_: i64,
13397 that: usize,
13398 req: *mut wire_cst_prepare_pay_onchain_request,
13399 ) {
13400 wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(port_, that, req)
13401 }
13402
13403 #[unsafe(no_mangle)]
13404 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment(
13405 port_: i64,
13406 that: usize,
13407 req: *mut wire_cst_prepare_receive_request,
13408 ) {
13409 wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(port_, that, req)
13410 }
13411
13412 #[unsafe(no_mangle)]
13413 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_refund(
13414 port_: i64,
13415 that: usize,
13416 req: *mut wire_cst_prepare_refund_request,
13417 ) {
13418 wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(port_, that, req)
13419 }
13420
13421 #[unsafe(no_mangle)]
13422 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_send_payment(
13423 port_: i64,
13424 that: usize,
13425 req: *mut wire_cst_prepare_send_request,
13426 ) {
13427 wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(port_, that, req)
13428 }
13429
13430 #[unsafe(no_mangle)]
13431 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_receive_payment(
13432 port_: i64,
13433 that: usize,
13434 req: *mut wire_cst_receive_payment_request,
13435 ) {
13436 wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(port_, that, req)
13437 }
13438
13439 #[unsafe(no_mangle)]
13440 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_recommended_fees(
13441 port_: i64,
13442 that: usize,
13443 ) {
13444 wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(port_, that)
13445 }
13446
13447 #[unsafe(no_mangle)]
13448 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_refund(
13449 port_: i64,
13450 that: usize,
13451 req: *mut wire_cst_refund_request,
13452 ) {
13453 wire__crate__bindings__BindingLiquidSdk_refund_impl(port_, that, req)
13454 }
13455
13456 #[unsafe(no_mangle)]
13457 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_register_webhook(
13458 port_: i64,
13459 that: usize,
13460 webhook_url: *mut wire_cst_list_prim_u_8_strict,
13461 ) {
13462 wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(port_, that, webhook_url)
13463 }
13464
13465 #[unsafe(no_mangle)]
13466 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps(
13467 port_: i64,
13468 that: usize,
13469 ) {
13470 wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(port_, that)
13471 }
13472
13473 #[unsafe(no_mangle)]
13474 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_restore(
13475 that: usize,
13476 req: *mut wire_cst_restore_request,
13477 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13478 wire__crate__bindings__BindingLiquidSdk_restore_impl(that, req)
13479 }
13480
13481 #[unsafe(no_mangle)]
13482 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_send_payment(
13483 port_: i64,
13484 that: usize,
13485 req: *mut wire_cst_send_payment_request,
13486 ) {
13487 wire__crate__bindings__BindingLiquidSdk_send_payment_impl(port_, that, req)
13488 }
13489
13490 #[unsafe(no_mangle)]
13491 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sign_message(
13492 that: usize,
13493 req: *mut wire_cst_sign_message_request,
13494 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13495 wire__crate__bindings__BindingLiquidSdk_sign_message_impl(that, req)
13496 }
13497
13498 #[unsafe(no_mangle)]
13499 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sync(
13500 port_: i64,
13501 that: usize,
13502 ) {
13503 wire__crate__bindings__BindingLiquidSdk_sync_impl(port_, that)
13504 }
13505
13506 #[unsafe(no_mangle)]
13507 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_unregister_webhook(
13508 port_: i64,
13509 that: usize,
13510 ) {
13511 wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(port_, that)
13512 }
13513
13514 #[unsafe(no_mangle)]
13515 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__binding_event_listener_on_event(
13516 port_: i64,
13517 that: *mut wire_cst_binding_event_listener,
13518 e: *mut wire_cst_sdk_event,
13519 ) {
13520 wire__crate__bindings__binding_event_listener_on_event_impl(port_, that, e)
13521 }
13522
13523 #[unsafe(no_mangle)]
13524 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__breez_log_stream(
13525 port_: i64,
13526 s: *mut wire_cst_list_prim_u_8_strict,
13527 ) {
13528 wire__crate__bindings__breez_log_stream_impl(port_, s)
13529 }
13530
13531 #[unsafe(no_mangle)]
13532 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__connect(
13533 port_: i64,
13534 req: *mut wire_cst_connect_request,
13535 ) {
13536 wire__crate__bindings__connect_impl(port_, req)
13537 }
13538
13539 #[unsafe(no_mangle)]
13540 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__default_config(
13541 network: i32,
13542 breez_api_key: *mut wire_cst_list_prim_u_8_strict,
13543 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13544 wire__crate__bindings__default_config_impl(network, breez_api_key)
13545 }
13546
13547 #[unsafe(no_mangle)]
13548 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__parse_invoice(
13549 input: *mut wire_cst_list_prim_u_8_strict,
13550 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13551 wire__crate__bindings__parse_invoice_impl(input)
13552 }
13553
13554 #[unsafe(no_mangle)]
13555 pub extern "C" fn frbgen_breez_liquid_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13556 ptr: *const std::ffi::c_void,
13557 ) {
13558 unsafe {
13559 StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::increment_strong_count(ptr as _);
13560 }
13561 }
13562
13563 #[unsafe(no_mangle)]
13564 pub extern "C" fn frbgen_breez_liquid_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13565 ptr: *const std::ffi::c_void,
13566 ) {
13567 unsafe {
13568 StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::decrement_strong_count(ptr as _);
13569 }
13570 }
13571
13572 #[unsafe(no_mangle)]
13573 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_accept_payment_proposed_fees_request(
13574 ) -> *mut wire_cst_accept_payment_proposed_fees_request {
13575 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13576 wire_cst_accept_payment_proposed_fees_request::new_with_null_ptr(),
13577 )
13578 }
13579
13580 #[unsafe(no_mangle)]
13581 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data(
13582 ) -> *mut wire_cst_aes_success_action_data {
13583 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13584 wire_cst_aes_success_action_data::new_with_null_ptr(),
13585 )
13586 }
13587
13588 #[unsafe(no_mangle)]
13589 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_decrypted(
13590 ) -> *mut wire_cst_aes_success_action_data_decrypted {
13591 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13592 wire_cst_aes_success_action_data_decrypted::new_with_null_ptr(),
13593 )
13594 }
13595
13596 #[unsafe(no_mangle)]
13597 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_result(
13598 ) -> *mut wire_cst_aes_success_action_data_result {
13599 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13600 wire_cst_aes_success_action_data_result::new_with_null_ptr(),
13601 )
13602 }
13603
13604 #[unsafe(no_mangle)]
13605 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_amount() -> *mut wire_cst_amount {
13606 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_amount::new_with_null_ptr())
13607 }
13608
13609 #[unsafe(no_mangle)]
13610 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_asset_info(
13611 ) -> *mut wire_cst_asset_info {
13612 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13613 wire_cst_asset_info::new_with_null_ptr(),
13614 )
13615 }
13616
13617 #[unsafe(no_mangle)]
13618 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_backup_request(
13619 ) -> *mut wire_cst_backup_request {
13620 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13621 wire_cst_backup_request::new_with_null_ptr(),
13622 )
13623 }
13624
13625 #[unsafe(no_mangle)]
13626 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_binding_event_listener(
13627 ) -> *mut wire_cst_binding_event_listener {
13628 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13629 wire_cst_binding_event_listener::new_with_null_ptr(),
13630 )
13631 }
13632
13633 #[unsafe(no_mangle)]
13634 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bitcoin_address_data(
13635 ) -> *mut wire_cst_bitcoin_address_data {
13636 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13637 wire_cst_bitcoin_address_data::new_with_null_ptr(),
13638 )
13639 }
13640
13641 #[unsafe(no_mangle)]
13642 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bool(value: bool) -> *mut bool {
13643 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13644 }
13645
13646 #[unsafe(no_mangle)]
13647 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_buy_bitcoin_request(
13648 ) -> *mut wire_cst_buy_bitcoin_request {
13649 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13650 wire_cst_buy_bitcoin_request::new_with_null_ptr(),
13651 )
13652 }
13653
13654 #[unsafe(no_mangle)]
13655 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_check_message_request(
13656 ) -> *mut wire_cst_check_message_request {
13657 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13658 wire_cst_check_message_request::new_with_null_ptr(),
13659 )
13660 }
13661
13662 #[unsafe(no_mangle)]
13663 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_connect_request(
13664 ) -> *mut wire_cst_connect_request {
13665 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13666 wire_cst_connect_request::new_with_null_ptr(),
13667 )
13668 }
13669
13670 #[unsafe(no_mangle)]
13671 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_create_bolt_12_invoice_request(
13672 ) -> *mut wire_cst_create_bolt_12_invoice_request {
13673 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13674 wire_cst_create_bolt_12_invoice_request::new_with_null_ptr(),
13675 )
13676 }
13677
13678 #[unsafe(no_mangle)]
13679 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_f_64(value: f64) -> *mut f64 {
13680 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13681 }
13682
13683 #[unsafe(no_mangle)]
13684 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_fetch_payment_proposed_fees_request(
13685 ) -> *mut wire_cst_fetch_payment_proposed_fees_request {
13686 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13687 wire_cst_fetch_payment_proposed_fees_request::new_with_null_ptr(),
13688 )
13689 }
13690
13691 #[unsafe(no_mangle)]
13692 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_get_payment_request(
13693 ) -> *mut wire_cst_get_payment_request {
13694 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13695 wire_cst_get_payment_request::new_with_null_ptr(),
13696 )
13697 }
13698
13699 #[unsafe(no_mangle)]
13700 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_i_64(value: i64) -> *mut i64 {
13701 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13702 }
13703
13704 #[unsafe(no_mangle)]
13705 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_liquid_address_data(
13706 ) -> *mut wire_cst_liquid_address_data {
13707 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13708 wire_cst_liquid_address_data::new_with_null_ptr(),
13709 )
13710 }
13711
13712 #[unsafe(no_mangle)]
13713 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payment_details(
13714 ) -> *mut wire_cst_list_payment_details {
13715 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13716 wire_cst_list_payment_details::new_with_null_ptr(),
13717 )
13718 }
13719
13720 #[unsafe(no_mangle)]
13721 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payments_request(
13722 ) -> *mut wire_cst_list_payments_request {
13723 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13724 wire_cst_list_payments_request::new_with_null_ptr(),
13725 )
13726 }
13727
13728 #[unsafe(no_mangle)]
13729 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_invoice(
13730 ) -> *mut wire_cst_ln_invoice {
13731 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13732 wire_cst_ln_invoice::new_with_null_ptr(),
13733 )
13734 }
13735
13736 #[unsafe(no_mangle)]
13737 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_offer() -> *mut wire_cst_ln_offer {
13738 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_ln_offer::new_with_null_ptr())
13739 }
13740
13741 #[unsafe(no_mangle)]
13742 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_auth_request_data(
13743 ) -> *mut wire_cst_ln_url_auth_request_data {
13744 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13745 wire_cst_ln_url_auth_request_data::new_with_null_ptr(),
13746 )
13747 }
13748
13749 #[unsafe(no_mangle)]
13750 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_error_data(
13751 ) -> *mut wire_cst_ln_url_error_data {
13752 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13753 wire_cst_ln_url_error_data::new_with_null_ptr(),
13754 )
13755 }
13756
13757 #[unsafe(no_mangle)]
13758 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_info(
13759 ) -> *mut wire_cst_ln_url_info {
13760 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13761 wire_cst_ln_url_info::new_with_null_ptr(),
13762 )
13763 }
13764
13765 #[unsafe(no_mangle)]
13766 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_error_data(
13767 ) -> *mut wire_cst_ln_url_pay_error_data {
13768 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13769 wire_cst_ln_url_pay_error_data::new_with_null_ptr(),
13770 )
13771 }
13772
13773 #[unsafe(no_mangle)]
13774 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request(
13775 ) -> *mut wire_cst_ln_url_pay_request {
13776 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13777 wire_cst_ln_url_pay_request::new_with_null_ptr(),
13778 )
13779 }
13780
13781 #[unsafe(no_mangle)]
13782 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request_data(
13783 ) -> *mut wire_cst_ln_url_pay_request_data {
13784 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13785 wire_cst_ln_url_pay_request_data::new_with_null_ptr(),
13786 )
13787 }
13788
13789 #[unsafe(no_mangle)]
13790 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_success_data(
13791 ) -> *mut wire_cst_ln_url_pay_success_data {
13792 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13793 wire_cst_ln_url_pay_success_data::new_with_null_ptr(),
13794 )
13795 }
13796
13797 #[unsafe(no_mangle)]
13798 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request(
13799 ) -> *mut wire_cst_ln_url_withdraw_request {
13800 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13801 wire_cst_ln_url_withdraw_request::new_with_null_ptr(),
13802 )
13803 }
13804
13805 #[unsafe(no_mangle)]
13806 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request_data(
13807 ) -> *mut wire_cst_ln_url_withdraw_request_data {
13808 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13809 wire_cst_ln_url_withdraw_request_data::new_with_null_ptr(),
13810 )
13811 }
13812
13813 #[unsafe(no_mangle)]
13814 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_success_data(
13815 ) -> *mut wire_cst_ln_url_withdraw_success_data {
13816 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13817 wire_cst_ln_url_withdraw_success_data::new_with_null_ptr(),
13818 )
13819 }
13820
13821 #[unsafe(no_mangle)]
13822 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_message_success_action_data(
13823 ) -> *mut wire_cst_message_success_action_data {
13824 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13825 wire_cst_message_success_action_data::new_with_null_ptr(),
13826 )
13827 }
13828
13829 #[unsafe(no_mangle)]
13830 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_amount(
13831 ) -> *mut wire_cst_pay_amount {
13832 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13833 wire_cst_pay_amount::new_with_null_ptr(),
13834 )
13835 }
13836
13837 #[unsafe(no_mangle)]
13838 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_onchain_request(
13839 ) -> *mut wire_cst_pay_onchain_request {
13840 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13841 wire_cst_pay_onchain_request::new_with_null_ptr(),
13842 )
13843 }
13844
13845 #[unsafe(no_mangle)]
13846 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_payment() -> *mut wire_cst_payment {
13847 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_payment::new_with_null_ptr())
13848 }
13849
13850 #[unsafe(no_mangle)]
13851 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_buy_bitcoin_request(
13852 ) -> *mut wire_cst_prepare_buy_bitcoin_request {
13853 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13854 wire_cst_prepare_buy_bitcoin_request::new_with_null_ptr(),
13855 )
13856 }
13857
13858 #[unsafe(no_mangle)]
13859 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_ln_url_pay_request(
13860 ) -> *mut wire_cst_prepare_ln_url_pay_request {
13861 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13862 wire_cst_prepare_ln_url_pay_request::new_with_null_ptr(),
13863 )
13864 }
13865
13866 #[unsafe(no_mangle)]
13867 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_pay_onchain_request(
13868 ) -> *mut wire_cst_prepare_pay_onchain_request {
13869 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13870 wire_cst_prepare_pay_onchain_request::new_with_null_ptr(),
13871 )
13872 }
13873
13874 #[unsafe(no_mangle)]
13875 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_receive_request(
13876 ) -> *mut wire_cst_prepare_receive_request {
13877 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13878 wire_cst_prepare_receive_request::new_with_null_ptr(),
13879 )
13880 }
13881
13882 #[unsafe(no_mangle)]
13883 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_refund_request(
13884 ) -> *mut wire_cst_prepare_refund_request {
13885 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13886 wire_cst_prepare_refund_request::new_with_null_ptr(),
13887 )
13888 }
13889
13890 #[unsafe(no_mangle)]
13891 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_send_request(
13892 ) -> *mut wire_cst_prepare_send_request {
13893 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13894 wire_cst_prepare_send_request::new_with_null_ptr(),
13895 )
13896 }
13897
13898 #[unsafe(no_mangle)]
13899 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_amount(
13900 ) -> *mut wire_cst_receive_amount {
13901 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13902 wire_cst_receive_amount::new_with_null_ptr(),
13903 )
13904 }
13905
13906 #[unsafe(no_mangle)]
13907 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_payment_request(
13908 ) -> *mut wire_cst_receive_payment_request {
13909 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13910 wire_cst_receive_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_refund_request(
13916 ) -> *mut wire_cst_refund_request {
13917 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13918 wire_cst_refund_request::new_with_null_ptr(),
13919 )
13920 }
13921
13922 #[unsafe(no_mangle)]
13923 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_restore_request(
13924 ) -> *mut wire_cst_restore_request {
13925 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13926 wire_cst_restore_request::new_with_null_ptr(),
13927 )
13928 }
13929
13930 #[unsafe(no_mangle)]
13931 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sdk_event() -> *mut wire_cst_sdk_event
13932 {
13933 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_sdk_event::new_with_null_ptr())
13934 }
13935
13936 #[unsafe(no_mangle)]
13937 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_send_payment_request(
13938 ) -> *mut wire_cst_send_payment_request {
13939 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13940 wire_cst_send_payment_request::new_with_null_ptr(),
13941 )
13942 }
13943
13944 #[unsafe(no_mangle)]
13945 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sign_message_request(
13946 ) -> *mut wire_cst_sign_message_request {
13947 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13948 wire_cst_sign_message_request::new_with_null_ptr(),
13949 )
13950 }
13951
13952 #[unsafe(no_mangle)]
13953 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action(
13954 ) -> *mut wire_cst_success_action {
13955 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13956 wire_cst_success_action::new_with_null_ptr(),
13957 )
13958 }
13959
13960 #[unsafe(no_mangle)]
13961 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action_processed(
13962 ) -> *mut wire_cst_success_action_processed {
13963 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13964 wire_cst_success_action_processed::new_with_null_ptr(),
13965 )
13966 }
13967
13968 #[unsafe(no_mangle)]
13969 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_symbol() -> *mut wire_cst_symbol {
13970 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_symbol::new_with_null_ptr())
13971 }
13972
13973 #[unsafe(no_mangle)]
13974 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_32(value: u32) -> *mut u32 {
13975 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13976 }
13977
13978 #[unsafe(no_mangle)]
13979 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_64(value: u64) -> *mut u64 {
13980 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13981 }
13982
13983 #[unsafe(no_mangle)]
13984 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_url_success_action_data(
13985 ) -> *mut wire_cst_url_success_action_data {
13986 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13987 wire_cst_url_success_action_data::new_with_null_ptr(),
13988 )
13989 }
13990
13991 #[unsafe(no_mangle)]
13992 pub extern "C" fn frbgen_breez_liquid_cst_new_list_String(
13993 len: i32,
13994 ) -> *mut wire_cst_list_String {
13995 let wrap = wire_cst_list_String {
13996 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13997 <*mut wire_cst_list_prim_u_8_strict>::new_with_null_ptr(),
13998 len,
13999 ),
14000 len,
14001 };
14002 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14003 }
14004
14005 #[unsafe(no_mangle)]
14006 pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_balance(
14007 len: i32,
14008 ) -> *mut wire_cst_list_asset_balance {
14009 let wrap = wire_cst_list_asset_balance {
14010 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14011 <wire_cst_asset_balance>::new_with_null_ptr(),
14012 len,
14013 ),
14014 len,
14015 };
14016 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14017 }
14018
14019 #[unsafe(no_mangle)]
14020 pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_metadata(
14021 len: i32,
14022 ) -> *mut wire_cst_list_asset_metadata {
14023 let wrap = wire_cst_list_asset_metadata {
14024 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14025 <wire_cst_asset_metadata>::new_with_null_ptr(),
14026 len,
14027 ),
14028 len,
14029 };
14030 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14031 }
14032
14033 #[unsafe(no_mangle)]
14034 pub extern "C" fn frbgen_breez_liquid_cst_new_list_external_input_parser(
14035 len: i32,
14036 ) -> *mut wire_cst_list_external_input_parser {
14037 let wrap = wire_cst_list_external_input_parser {
14038 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14039 <wire_cst_external_input_parser>::new_with_null_ptr(),
14040 len,
14041 ),
14042 len,
14043 };
14044 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14045 }
14046
14047 #[unsafe(no_mangle)]
14048 pub extern "C" fn frbgen_breez_liquid_cst_new_list_fiat_currency(
14049 len: i32,
14050 ) -> *mut wire_cst_list_fiat_currency {
14051 let wrap = wire_cst_list_fiat_currency {
14052 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14053 <wire_cst_fiat_currency>::new_with_null_ptr(),
14054 len,
14055 ),
14056 len,
14057 };
14058 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14059 }
14060
14061 #[unsafe(no_mangle)]
14062 pub extern "C" fn frbgen_breez_liquid_cst_new_list_ln_offer_blinded_path(
14063 len: i32,
14064 ) -> *mut wire_cst_list_ln_offer_blinded_path {
14065 let wrap = wire_cst_list_ln_offer_blinded_path {
14066 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14067 <wire_cst_ln_offer_blinded_path>::new_with_null_ptr(),
14068 len,
14069 ),
14070 len,
14071 };
14072 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14073 }
14074
14075 #[unsafe(no_mangle)]
14076 pub extern "C" fn frbgen_breez_liquid_cst_new_list_locale_overrides(
14077 len: i32,
14078 ) -> *mut wire_cst_list_locale_overrides {
14079 let wrap = wire_cst_list_locale_overrides {
14080 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14081 <wire_cst_locale_overrides>::new_with_null_ptr(),
14082 len,
14083 ),
14084 len,
14085 };
14086 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14087 }
14088
14089 #[unsafe(no_mangle)]
14090 pub extern "C" fn frbgen_breez_liquid_cst_new_list_localized_name(
14091 len: i32,
14092 ) -> *mut wire_cst_list_localized_name {
14093 let wrap = wire_cst_list_localized_name {
14094 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14095 <wire_cst_localized_name>::new_with_null_ptr(),
14096 len,
14097 ),
14098 len,
14099 };
14100 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14101 }
14102
14103 #[unsafe(no_mangle)]
14104 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment(
14105 len: i32,
14106 ) -> *mut wire_cst_list_payment {
14107 let wrap = wire_cst_list_payment {
14108 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14109 <wire_cst_payment>::new_with_null_ptr(),
14110 len,
14111 ),
14112 len,
14113 };
14114 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14115 }
14116
14117 #[unsafe(no_mangle)]
14118 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_state(
14119 len: i32,
14120 ) -> *mut wire_cst_list_payment_state {
14121 let wrap = wire_cst_list_payment_state {
14122 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14123 len,
14124 };
14125 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14126 }
14127
14128 #[unsafe(no_mangle)]
14129 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_type(
14130 len: i32,
14131 ) -> *mut wire_cst_list_payment_type {
14132 let wrap = wire_cst_list_payment_type {
14133 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14134 len,
14135 };
14136 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14137 }
14138
14139 #[unsafe(no_mangle)]
14140 pub extern "C" fn frbgen_breez_liquid_cst_new_list_prim_u_8_strict(
14141 len: i32,
14142 ) -> *mut wire_cst_list_prim_u_8_strict {
14143 let ans = wire_cst_list_prim_u_8_strict {
14144 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14145 len,
14146 };
14147 flutter_rust_bridge::for_generated::new_leak_box_ptr(ans)
14148 }
14149
14150 #[unsafe(no_mangle)]
14151 pub extern "C" fn frbgen_breez_liquid_cst_new_list_rate(len: i32) -> *mut wire_cst_list_rate {
14152 let wrap = wire_cst_list_rate {
14153 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14154 <wire_cst_rate>::new_with_null_ptr(),
14155 len,
14156 ),
14157 len,
14158 };
14159 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14160 }
14161
14162 #[unsafe(no_mangle)]
14163 pub extern "C" fn frbgen_breez_liquid_cst_new_list_refundable_swap(
14164 len: i32,
14165 ) -> *mut wire_cst_list_refundable_swap {
14166 let wrap = wire_cst_list_refundable_swap {
14167 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14168 <wire_cst_refundable_swap>::new_with_null_ptr(),
14169 len,
14170 ),
14171 len,
14172 };
14173 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14174 }
14175
14176 #[unsafe(no_mangle)]
14177 pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint(
14178 len: i32,
14179 ) -> *mut wire_cst_list_route_hint {
14180 let wrap = wire_cst_list_route_hint {
14181 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14182 <wire_cst_route_hint>::new_with_null_ptr(),
14183 len,
14184 ),
14185 len,
14186 };
14187 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14188 }
14189
14190 #[unsafe(no_mangle)]
14191 pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint_hop(
14192 len: i32,
14193 ) -> *mut wire_cst_list_route_hint_hop {
14194 let wrap = wire_cst_list_route_hint_hop {
14195 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14196 <wire_cst_route_hint_hop>::new_with_null_ptr(),
14197 len,
14198 ),
14199 len,
14200 };
14201 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14202 }
14203
14204 #[repr(C)]
14205 #[derive(Clone, Copy)]
14206 pub struct wire_cst_accept_payment_proposed_fees_request {
14207 response: wire_cst_fetch_payment_proposed_fees_response,
14208 }
14209 #[repr(C)]
14210 #[derive(Clone, Copy)]
14211 pub struct wire_cst_aes_success_action_data {
14212 description: *mut wire_cst_list_prim_u_8_strict,
14213 ciphertext: *mut wire_cst_list_prim_u_8_strict,
14214 iv: *mut wire_cst_list_prim_u_8_strict,
14215 }
14216 #[repr(C)]
14217 #[derive(Clone, Copy)]
14218 pub struct wire_cst_aes_success_action_data_decrypted {
14219 description: *mut wire_cst_list_prim_u_8_strict,
14220 plaintext: *mut wire_cst_list_prim_u_8_strict,
14221 }
14222 #[repr(C)]
14223 #[derive(Clone, Copy)]
14224 pub struct wire_cst_aes_success_action_data_result {
14225 tag: i32,
14226 kind: AesSuccessActionDataResultKind,
14227 }
14228 #[repr(C)]
14229 #[derive(Clone, Copy)]
14230 pub union AesSuccessActionDataResultKind {
14231 Decrypted: wire_cst_AesSuccessActionDataResult_Decrypted,
14232 ErrorStatus: wire_cst_AesSuccessActionDataResult_ErrorStatus,
14233 nil__: (),
14234 }
14235 #[repr(C)]
14236 #[derive(Clone, Copy)]
14237 pub struct wire_cst_AesSuccessActionDataResult_Decrypted {
14238 data: *mut wire_cst_aes_success_action_data_decrypted,
14239 }
14240 #[repr(C)]
14241 #[derive(Clone, Copy)]
14242 pub struct wire_cst_AesSuccessActionDataResult_ErrorStatus {
14243 reason: *mut wire_cst_list_prim_u_8_strict,
14244 }
14245 #[repr(C)]
14246 #[derive(Clone, Copy)]
14247 pub struct wire_cst_amount {
14248 tag: i32,
14249 kind: AmountKind,
14250 }
14251 #[repr(C)]
14252 #[derive(Clone, Copy)]
14253 pub union AmountKind {
14254 Bitcoin: wire_cst_Amount_Bitcoin,
14255 Currency: wire_cst_Amount_Currency,
14256 nil__: (),
14257 }
14258 #[repr(C)]
14259 #[derive(Clone, Copy)]
14260 pub struct wire_cst_Amount_Bitcoin {
14261 amount_msat: u64,
14262 }
14263 #[repr(C)]
14264 #[derive(Clone, Copy)]
14265 pub struct wire_cst_Amount_Currency {
14266 iso4217_code: *mut wire_cst_list_prim_u_8_strict,
14267 fractional_amount: u64,
14268 }
14269 #[repr(C)]
14270 #[derive(Clone, Copy)]
14271 pub struct wire_cst_asset_balance {
14272 asset_id: *mut wire_cst_list_prim_u_8_strict,
14273 balance_sat: u64,
14274 name: *mut wire_cst_list_prim_u_8_strict,
14275 ticker: *mut wire_cst_list_prim_u_8_strict,
14276 balance: *mut f64,
14277 }
14278 #[repr(C)]
14279 #[derive(Clone, Copy)]
14280 pub struct wire_cst_asset_info {
14281 name: *mut wire_cst_list_prim_u_8_strict,
14282 ticker: *mut wire_cst_list_prim_u_8_strict,
14283 amount: f64,
14284 fees: *mut f64,
14285 }
14286 #[repr(C)]
14287 #[derive(Clone, Copy)]
14288 pub struct wire_cst_asset_metadata {
14289 asset_id: *mut wire_cst_list_prim_u_8_strict,
14290 name: *mut wire_cst_list_prim_u_8_strict,
14291 ticker: *mut wire_cst_list_prim_u_8_strict,
14292 precision: u8,
14293 fiat_id: *mut wire_cst_list_prim_u_8_strict,
14294 }
14295 #[repr(C)]
14296 #[derive(Clone, Copy)]
14297 pub struct wire_cst_backup_request {
14298 backup_path: *mut wire_cst_list_prim_u_8_strict,
14299 }
14300 #[repr(C)]
14301 #[derive(Clone, Copy)]
14302 pub struct wire_cst_binding_event_listener {
14303 stream: *mut wire_cst_list_prim_u_8_strict,
14304 }
14305 #[repr(C)]
14306 #[derive(Clone, Copy)]
14307 pub struct wire_cst_bitcoin_address_data {
14308 address: *mut wire_cst_list_prim_u_8_strict,
14309 network: i32,
14310 amount_sat: *mut u64,
14311 label: *mut wire_cst_list_prim_u_8_strict,
14312 message: *mut wire_cst_list_prim_u_8_strict,
14313 }
14314 #[repr(C)]
14315 #[derive(Clone, Copy)]
14316 pub struct wire_cst_blockchain_explorer {
14317 tag: i32,
14318 kind: BlockchainExplorerKind,
14319 }
14320 #[repr(C)]
14321 #[derive(Clone, Copy)]
14322 pub union BlockchainExplorerKind {
14323 Electrum: wire_cst_BlockchainExplorer_Electrum,
14324 Esplora: wire_cst_BlockchainExplorer_Esplora,
14325 nil__: (),
14326 }
14327 #[repr(C)]
14328 #[derive(Clone, Copy)]
14329 pub struct wire_cst_BlockchainExplorer_Electrum {
14330 url: *mut wire_cst_list_prim_u_8_strict,
14331 }
14332 #[repr(C)]
14333 #[derive(Clone, Copy)]
14334 pub struct wire_cst_BlockchainExplorer_Esplora {
14335 url: *mut wire_cst_list_prim_u_8_strict,
14336 use_waterfalls: bool,
14337 }
14338 #[repr(C)]
14339 #[derive(Clone, Copy)]
14340 pub struct wire_cst_blockchain_info {
14341 liquid_tip: u32,
14342 bitcoin_tip: u32,
14343 }
14344 #[repr(C)]
14345 #[derive(Clone, Copy)]
14346 pub struct wire_cst_buy_bitcoin_request {
14347 prepare_response: wire_cst_prepare_buy_bitcoin_response,
14348 redirect_url: *mut wire_cst_list_prim_u_8_strict,
14349 }
14350 #[repr(C)]
14351 #[derive(Clone, Copy)]
14352 pub struct wire_cst_check_message_request {
14353 message: *mut wire_cst_list_prim_u_8_strict,
14354 pubkey: *mut wire_cst_list_prim_u_8_strict,
14355 signature: *mut wire_cst_list_prim_u_8_strict,
14356 }
14357 #[repr(C)]
14358 #[derive(Clone, Copy)]
14359 pub struct wire_cst_check_message_response {
14360 is_valid: bool,
14361 }
14362 #[repr(C)]
14363 #[derive(Clone, Copy)]
14364 pub struct wire_cst_config {
14365 liquid_explorer: wire_cst_blockchain_explorer,
14366 bitcoin_explorer: wire_cst_blockchain_explorer,
14367 working_dir: *mut wire_cst_list_prim_u_8_strict,
14368 network: i32,
14369 payment_timeout_sec: u64,
14370 sync_service_url: *mut wire_cst_list_prim_u_8_strict,
14371 zero_conf_max_amount_sat: *mut u64,
14372 breez_api_key: *mut wire_cst_list_prim_u_8_strict,
14373 external_input_parsers: *mut wire_cst_list_external_input_parser,
14374 use_default_external_input_parsers: bool,
14375 onchain_fee_rate_leeway_sat: *mut u64,
14376 asset_metadata: *mut wire_cst_list_asset_metadata,
14377 sideswap_api_key: *mut wire_cst_list_prim_u_8_strict,
14378 use_magic_routing_hints: bool,
14379 }
14380 #[repr(C)]
14381 #[derive(Clone, Copy)]
14382 pub struct wire_cst_connect_request {
14383 config: wire_cst_config,
14384 mnemonic: *mut wire_cst_list_prim_u_8_strict,
14385 passphrase: *mut wire_cst_list_prim_u_8_strict,
14386 seed: *mut wire_cst_list_prim_u_8_strict,
14387 }
14388 #[repr(C)]
14389 #[derive(Clone, Copy)]
14390 pub struct wire_cst_create_bolt_12_invoice_request {
14391 offer: *mut wire_cst_list_prim_u_8_strict,
14392 invoice_request: *mut wire_cst_list_prim_u_8_strict,
14393 }
14394 #[repr(C)]
14395 #[derive(Clone, Copy)]
14396 pub struct wire_cst_create_bolt_12_invoice_response {
14397 invoice: *mut wire_cst_list_prim_u_8_strict,
14398 }
14399 #[repr(C)]
14400 #[derive(Clone, Copy)]
14401 pub struct wire_cst_currency_info {
14402 name: *mut wire_cst_list_prim_u_8_strict,
14403 fraction_size: u32,
14404 spacing: *mut u32,
14405 symbol: *mut wire_cst_symbol,
14406 uniq_symbol: *mut wire_cst_symbol,
14407 localized_name: *mut wire_cst_list_localized_name,
14408 locale_overrides: *mut wire_cst_list_locale_overrides,
14409 }
14410 #[repr(C)]
14411 #[derive(Clone, Copy)]
14412 pub struct wire_cst_external_input_parser {
14413 provider_id: *mut wire_cst_list_prim_u_8_strict,
14414 input_regex: *mut wire_cst_list_prim_u_8_strict,
14415 parser_url: *mut wire_cst_list_prim_u_8_strict,
14416 }
14417 #[repr(C)]
14418 #[derive(Clone, Copy)]
14419 pub struct wire_cst_fetch_payment_proposed_fees_request {
14420 swap_id: *mut wire_cst_list_prim_u_8_strict,
14421 }
14422 #[repr(C)]
14423 #[derive(Clone, Copy)]
14424 pub struct wire_cst_fetch_payment_proposed_fees_response {
14425 swap_id: *mut wire_cst_list_prim_u_8_strict,
14426 fees_sat: u64,
14427 payer_amount_sat: u64,
14428 receiver_amount_sat: u64,
14429 }
14430 #[repr(C)]
14431 #[derive(Clone, Copy)]
14432 pub struct wire_cst_fiat_currency {
14433 id: *mut wire_cst_list_prim_u_8_strict,
14434 info: wire_cst_currency_info,
14435 }
14436 #[repr(C)]
14437 #[derive(Clone, Copy)]
14438 pub struct wire_cst_get_info_response {
14439 wallet_info: wire_cst_wallet_info,
14440 blockchain_info: wire_cst_blockchain_info,
14441 }
14442 #[repr(C)]
14443 #[derive(Clone, Copy)]
14444 pub struct wire_cst_get_payment_request {
14445 tag: i32,
14446 kind: GetPaymentRequestKind,
14447 }
14448 #[repr(C)]
14449 #[derive(Clone, Copy)]
14450 pub union GetPaymentRequestKind {
14451 PaymentHash: wire_cst_GetPaymentRequest_PaymentHash,
14452 SwapId: wire_cst_GetPaymentRequest_SwapId,
14453 nil__: (),
14454 }
14455 #[repr(C)]
14456 #[derive(Clone, Copy)]
14457 pub struct wire_cst_GetPaymentRequest_PaymentHash {
14458 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14459 }
14460 #[repr(C)]
14461 #[derive(Clone, Copy)]
14462 pub struct wire_cst_GetPaymentRequest_SwapId {
14463 swap_id: *mut wire_cst_list_prim_u_8_strict,
14464 }
14465 #[repr(C)]
14466 #[derive(Clone, Copy)]
14467 pub struct wire_cst_input_type {
14468 tag: i32,
14469 kind: InputTypeKind,
14470 }
14471 #[repr(C)]
14472 #[derive(Clone, Copy)]
14473 pub union InputTypeKind {
14474 BitcoinAddress: wire_cst_InputType_BitcoinAddress,
14475 LiquidAddress: wire_cst_InputType_LiquidAddress,
14476 Bolt11: wire_cst_InputType_Bolt11,
14477 Bolt12Offer: wire_cst_InputType_Bolt12Offer,
14478 NodeId: wire_cst_InputType_NodeId,
14479 Url: wire_cst_InputType_Url,
14480 LnUrlPay: wire_cst_InputType_LnUrlPay,
14481 LnUrlWithdraw: wire_cst_InputType_LnUrlWithdraw,
14482 LnUrlAuth: wire_cst_InputType_LnUrlAuth,
14483 LnUrlError: wire_cst_InputType_LnUrlError,
14484 nil__: (),
14485 }
14486 #[repr(C)]
14487 #[derive(Clone, Copy)]
14488 pub struct wire_cst_InputType_BitcoinAddress {
14489 address: *mut wire_cst_bitcoin_address_data,
14490 }
14491 #[repr(C)]
14492 #[derive(Clone, Copy)]
14493 pub struct wire_cst_InputType_LiquidAddress {
14494 address: *mut wire_cst_liquid_address_data,
14495 }
14496 #[repr(C)]
14497 #[derive(Clone, Copy)]
14498 pub struct wire_cst_InputType_Bolt11 {
14499 invoice: *mut wire_cst_ln_invoice,
14500 }
14501 #[repr(C)]
14502 #[derive(Clone, Copy)]
14503 pub struct wire_cst_InputType_Bolt12Offer {
14504 offer: *mut wire_cst_ln_offer,
14505 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14506 }
14507 #[repr(C)]
14508 #[derive(Clone, Copy)]
14509 pub struct wire_cst_InputType_NodeId {
14510 node_id: *mut wire_cst_list_prim_u_8_strict,
14511 }
14512 #[repr(C)]
14513 #[derive(Clone, Copy)]
14514 pub struct wire_cst_InputType_Url {
14515 url: *mut wire_cst_list_prim_u_8_strict,
14516 }
14517 #[repr(C)]
14518 #[derive(Clone, Copy)]
14519 pub struct wire_cst_InputType_LnUrlPay {
14520 data: *mut wire_cst_ln_url_pay_request_data,
14521 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14522 }
14523 #[repr(C)]
14524 #[derive(Clone, Copy)]
14525 pub struct wire_cst_InputType_LnUrlWithdraw {
14526 data: *mut wire_cst_ln_url_withdraw_request_data,
14527 }
14528 #[repr(C)]
14529 #[derive(Clone, Copy)]
14530 pub struct wire_cst_InputType_LnUrlAuth {
14531 data: *mut wire_cst_ln_url_auth_request_data,
14532 }
14533 #[repr(C)]
14534 #[derive(Clone, Copy)]
14535 pub struct wire_cst_InputType_LnUrlError {
14536 data: *mut wire_cst_ln_url_error_data,
14537 }
14538 #[repr(C)]
14539 #[derive(Clone, Copy)]
14540 pub struct wire_cst_lightning_payment_limits_response {
14541 send: wire_cst_limits,
14542 receive: wire_cst_limits,
14543 }
14544 #[repr(C)]
14545 #[derive(Clone, Copy)]
14546 pub struct wire_cst_limits {
14547 min_sat: u64,
14548 max_sat: u64,
14549 max_zero_conf_sat: u64,
14550 }
14551 #[repr(C)]
14552 #[derive(Clone, Copy)]
14553 pub struct wire_cst_liquid_address_data {
14554 address: *mut wire_cst_list_prim_u_8_strict,
14555 network: i32,
14556 asset_id: *mut wire_cst_list_prim_u_8_strict,
14557 amount: *mut f64,
14558 amount_sat: *mut u64,
14559 label: *mut wire_cst_list_prim_u_8_strict,
14560 message: *mut wire_cst_list_prim_u_8_strict,
14561 }
14562 #[repr(C)]
14563 #[derive(Clone, Copy)]
14564 pub struct wire_cst_list_String {
14565 ptr: *mut *mut wire_cst_list_prim_u_8_strict,
14566 len: i32,
14567 }
14568 #[repr(C)]
14569 #[derive(Clone, Copy)]
14570 pub struct wire_cst_list_asset_balance {
14571 ptr: *mut wire_cst_asset_balance,
14572 len: i32,
14573 }
14574 #[repr(C)]
14575 #[derive(Clone, Copy)]
14576 pub struct wire_cst_list_asset_metadata {
14577 ptr: *mut wire_cst_asset_metadata,
14578 len: i32,
14579 }
14580 #[repr(C)]
14581 #[derive(Clone, Copy)]
14582 pub struct wire_cst_list_external_input_parser {
14583 ptr: *mut wire_cst_external_input_parser,
14584 len: i32,
14585 }
14586 #[repr(C)]
14587 #[derive(Clone, Copy)]
14588 pub struct wire_cst_list_fiat_currency {
14589 ptr: *mut wire_cst_fiat_currency,
14590 len: i32,
14591 }
14592 #[repr(C)]
14593 #[derive(Clone, Copy)]
14594 pub struct wire_cst_list_ln_offer_blinded_path {
14595 ptr: *mut wire_cst_ln_offer_blinded_path,
14596 len: i32,
14597 }
14598 #[repr(C)]
14599 #[derive(Clone, Copy)]
14600 pub struct wire_cst_list_locale_overrides {
14601 ptr: *mut wire_cst_locale_overrides,
14602 len: i32,
14603 }
14604 #[repr(C)]
14605 #[derive(Clone, Copy)]
14606 pub struct wire_cst_list_localized_name {
14607 ptr: *mut wire_cst_localized_name,
14608 len: i32,
14609 }
14610 #[repr(C)]
14611 #[derive(Clone, Copy)]
14612 pub struct wire_cst_list_payment {
14613 ptr: *mut wire_cst_payment,
14614 len: i32,
14615 }
14616 #[repr(C)]
14617 #[derive(Clone, Copy)]
14618 pub struct wire_cst_list_payment_details {
14619 tag: i32,
14620 kind: ListPaymentDetailsKind,
14621 }
14622 #[repr(C)]
14623 #[derive(Clone, Copy)]
14624 pub union ListPaymentDetailsKind {
14625 Liquid: wire_cst_ListPaymentDetails_Liquid,
14626 Bitcoin: wire_cst_ListPaymentDetails_Bitcoin,
14627 nil__: (),
14628 }
14629 #[repr(C)]
14630 #[derive(Clone, Copy)]
14631 pub struct wire_cst_ListPaymentDetails_Liquid {
14632 asset_id: *mut wire_cst_list_prim_u_8_strict,
14633 destination: *mut wire_cst_list_prim_u_8_strict,
14634 }
14635 #[repr(C)]
14636 #[derive(Clone, Copy)]
14637 pub struct wire_cst_ListPaymentDetails_Bitcoin {
14638 address: *mut wire_cst_list_prim_u_8_strict,
14639 }
14640 #[repr(C)]
14641 #[derive(Clone, Copy)]
14642 pub struct wire_cst_list_payment_state {
14643 ptr: *mut i32,
14644 len: i32,
14645 }
14646 #[repr(C)]
14647 #[derive(Clone, Copy)]
14648 pub struct wire_cst_list_payment_type {
14649 ptr: *mut i32,
14650 len: i32,
14651 }
14652 #[repr(C)]
14653 #[derive(Clone, Copy)]
14654 pub struct wire_cst_list_payments_request {
14655 filters: *mut wire_cst_list_payment_type,
14656 states: *mut wire_cst_list_payment_state,
14657 from_timestamp: *mut i64,
14658 to_timestamp: *mut i64,
14659 offset: *mut u32,
14660 limit: *mut u32,
14661 details: *mut wire_cst_list_payment_details,
14662 sort_ascending: *mut bool,
14663 }
14664 #[repr(C)]
14665 #[derive(Clone, Copy)]
14666 pub struct wire_cst_list_prim_u_8_strict {
14667 ptr: *mut u8,
14668 len: i32,
14669 }
14670 #[repr(C)]
14671 #[derive(Clone, Copy)]
14672 pub struct wire_cst_list_rate {
14673 ptr: *mut wire_cst_rate,
14674 len: i32,
14675 }
14676 #[repr(C)]
14677 #[derive(Clone, Copy)]
14678 pub struct wire_cst_list_refundable_swap {
14679 ptr: *mut wire_cst_refundable_swap,
14680 len: i32,
14681 }
14682 #[repr(C)]
14683 #[derive(Clone, Copy)]
14684 pub struct wire_cst_list_route_hint {
14685 ptr: *mut wire_cst_route_hint,
14686 len: i32,
14687 }
14688 #[repr(C)]
14689 #[derive(Clone, Copy)]
14690 pub struct wire_cst_list_route_hint_hop {
14691 ptr: *mut wire_cst_route_hint_hop,
14692 len: i32,
14693 }
14694 #[repr(C)]
14695 #[derive(Clone, Copy)]
14696 pub struct wire_cst_ln_invoice {
14697 bolt11: *mut wire_cst_list_prim_u_8_strict,
14698 network: i32,
14699 payee_pubkey: *mut wire_cst_list_prim_u_8_strict,
14700 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14701 description: *mut wire_cst_list_prim_u_8_strict,
14702 description_hash: *mut wire_cst_list_prim_u_8_strict,
14703 amount_msat: *mut u64,
14704 timestamp: u64,
14705 expiry: u64,
14706 routing_hints: *mut wire_cst_list_route_hint,
14707 payment_secret: *mut wire_cst_list_prim_u_8_strict,
14708 min_final_cltv_expiry_delta: u64,
14709 }
14710 #[repr(C)]
14711 #[derive(Clone, Copy)]
14712 pub struct wire_cst_ln_offer {
14713 offer: *mut wire_cst_list_prim_u_8_strict,
14714 chains: *mut wire_cst_list_String,
14715 min_amount: *mut wire_cst_amount,
14716 description: *mut wire_cst_list_prim_u_8_strict,
14717 absolute_expiry: *mut u64,
14718 issuer: *mut wire_cst_list_prim_u_8_strict,
14719 signing_pubkey: *mut wire_cst_list_prim_u_8_strict,
14720 paths: *mut wire_cst_list_ln_offer_blinded_path,
14721 }
14722 #[repr(C)]
14723 #[derive(Clone, Copy)]
14724 pub struct wire_cst_ln_offer_blinded_path {
14725 blinded_hops: *mut wire_cst_list_String,
14726 }
14727 #[repr(C)]
14728 #[derive(Clone, Copy)]
14729 pub struct wire_cst_ln_url_auth_error {
14730 tag: i32,
14731 kind: LnUrlAuthErrorKind,
14732 }
14733 #[repr(C)]
14734 #[derive(Clone, Copy)]
14735 pub union LnUrlAuthErrorKind {
14736 Generic: wire_cst_LnUrlAuthError_Generic,
14737 InvalidUri: wire_cst_LnUrlAuthError_InvalidUri,
14738 ServiceConnectivity: wire_cst_LnUrlAuthError_ServiceConnectivity,
14739 nil__: (),
14740 }
14741 #[repr(C)]
14742 #[derive(Clone, Copy)]
14743 pub struct wire_cst_LnUrlAuthError_Generic {
14744 err: *mut wire_cst_list_prim_u_8_strict,
14745 }
14746 #[repr(C)]
14747 #[derive(Clone, Copy)]
14748 pub struct wire_cst_LnUrlAuthError_InvalidUri {
14749 err: *mut wire_cst_list_prim_u_8_strict,
14750 }
14751 #[repr(C)]
14752 #[derive(Clone, Copy)]
14753 pub struct wire_cst_LnUrlAuthError_ServiceConnectivity {
14754 err: *mut wire_cst_list_prim_u_8_strict,
14755 }
14756 #[repr(C)]
14757 #[derive(Clone, Copy)]
14758 pub struct wire_cst_ln_url_auth_request_data {
14759 k1: *mut wire_cst_list_prim_u_8_strict,
14760 action: *mut wire_cst_list_prim_u_8_strict,
14761 domain: *mut wire_cst_list_prim_u_8_strict,
14762 url: *mut wire_cst_list_prim_u_8_strict,
14763 }
14764 #[repr(C)]
14765 #[derive(Clone, Copy)]
14766 pub struct wire_cst_ln_url_callback_status {
14767 tag: i32,
14768 kind: LnUrlCallbackStatusKind,
14769 }
14770 #[repr(C)]
14771 #[derive(Clone, Copy)]
14772 pub union LnUrlCallbackStatusKind {
14773 ErrorStatus: wire_cst_LnUrlCallbackStatus_ErrorStatus,
14774 nil__: (),
14775 }
14776 #[repr(C)]
14777 #[derive(Clone, Copy)]
14778 pub struct wire_cst_LnUrlCallbackStatus_ErrorStatus {
14779 data: *mut wire_cst_ln_url_error_data,
14780 }
14781 #[repr(C)]
14782 #[derive(Clone, Copy)]
14783 pub struct wire_cst_ln_url_error_data {
14784 reason: *mut wire_cst_list_prim_u_8_strict,
14785 }
14786 #[repr(C)]
14787 #[derive(Clone, Copy)]
14788 pub struct wire_cst_ln_url_info {
14789 ln_address: *mut wire_cst_list_prim_u_8_strict,
14790 lnurl_pay_comment: *mut wire_cst_list_prim_u_8_strict,
14791 lnurl_pay_domain: *mut wire_cst_list_prim_u_8_strict,
14792 lnurl_pay_metadata: *mut wire_cst_list_prim_u_8_strict,
14793 lnurl_pay_success_action: *mut wire_cst_success_action_processed,
14794 lnurl_pay_unprocessed_success_action: *mut wire_cst_success_action,
14795 lnurl_withdraw_endpoint: *mut wire_cst_list_prim_u_8_strict,
14796 }
14797 #[repr(C)]
14798 #[derive(Clone, Copy)]
14799 pub struct wire_cst_ln_url_pay_error {
14800 tag: i32,
14801 kind: LnUrlPayErrorKind,
14802 }
14803 #[repr(C)]
14804 #[derive(Clone, Copy)]
14805 pub union LnUrlPayErrorKind {
14806 Generic: wire_cst_LnUrlPayError_Generic,
14807 InsufficientBalance: wire_cst_LnUrlPayError_InsufficientBalance,
14808 InvalidAmount: wire_cst_LnUrlPayError_InvalidAmount,
14809 InvalidInvoice: wire_cst_LnUrlPayError_InvalidInvoice,
14810 InvalidNetwork: wire_cst_LnUrlPayError_InvalidNetwork,
14811 InvalidUri: wire_cst_LnUrlPayError_InvalidUri,
14812 InvoiceExpired: wire_cst_LnUrlPayError_InvoiceExpired,
14813 PaymentFailed: wire_cst_LnUrlPayError_PaymentFailed,
14814 PaymentTimeout: wire_cst_LnUrlPayError_PaymentTimeout,
14815 RouteNotFound: wire_cst_LnUrlPayError_RouteNotFound,
14816 RouteTooExpensive: wire_cst_LnUrlPayError_RouteTooExpensive,
14817 ServiceConnectivity: wire_cst_LnUrlPayError_ServiceConnectivity,
14818 nil__: (),
14819 }
14820 #[repr(C)]
14821 #[derive(Clone, Copy)]
14822 pub struct wire_cst_LnUrlPayError_Generic {
14823 err: *mut wire_cst_list_prim_u_8_strict,
14824 }
14825 #[repr(C)]
14826 #[derive(Clone, Copy)]
14827 pub struct wire_cst_LnUrlPayError_InsufficientBalance {
14828 err: *mut wire_cst_list_prim_u_8_strict,
14829 }
14830 #[repr(C)]
14831 #[derive(Clone, Copy)]
14832 pub struct wire_cst_LnUrlPayError_InvalidAmount {
14833 err: *mut wire_cst_list_prim_u_8_strict,
14834 }
14835 #[repr(C)]
14836 #[derive(Clone, Copy)]
14837 pub struct wire_cst_LnUrlPayError_InvalidInvoice {
14838 err: *mut wire_cst_list_prim_u_8_strict,
14839 }
14840 #[repr(C)]
14841 #[derive(Clone, Copy)]
14842 pub struct wire_cst_LnUrlPayError_InvalidNetwork {
14843 err: *mut wire_cst_list_prim_u_8_strict,
14844 }
14845 #[repr(C)]
14846 #[derive(Clone, Copy)]
14847 pub struct wire_cst_LnUrlPayError_InvalidUri {
14848 err: *mut wire_cst_list_prim_u_8_strict,
14849 }
14850 #[repr(C)]
14851 #[derive(Clone, Copy)]
14852 pub struct wire_cst_LnUrlPayError_InvoiceExpired {
14853 err: *mut wire_cst_list_prim_u_8_strict,
14854 }
14855 #[repr(C)]
14856 #[derive(Clone, Copy)]
14857 pub struct wire_cst_LnUrlPayError_PaymentFailed {
14858 err: *mut wire_cst_list_prim_u_8_strict,
14859 }
14860 #[repr(C)]
14861 #[derive(Clone, Copy)]
14862 pub struct wire_cst_LnUrlPayError_PaymentTimeout {
14863 err: *mut wire_cst_list_prim_u_8_strict,
14864 }
14865 #[repr(C)]
14866 #[derive(Clone, Copy)]
14867 pub struct wire_cst_LnUrlPayError_RouteNotFound {
14868 err: *mut wire_cst_list_prim_u_8_strict,
14869 }
14870 #[repr(C)]
14871 #[derive(Clone, Copy)]
14872 pub struct wire_cst_LnUrlPayError_RouteTooExpensive {
14873 err: *mut wire_cst_list_prim_u_8_strict,
14874 }
14875 #[repr(C)]
14876 #[derive(Clone, Copy)]
14877 pub struct wire_cst_LnUrlPayError_ServiceConnectivity {
14878 err: *mut wire_cst_list_prim_u_8_strict,
14879 }
14880 #[repr(C)]
14881 #[derive(Clone, Copy)]
14882 pub struct wire_cst_ln_url_pay_error_data {
14883 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14884 reason: *mut wire_cst_list_prim_u_8_strict,
14885 }
14886 #[repr(C)]
14887 #[derive(Clone, Copy)]
14888 pub struct wire_cst_ln_url_pay_request {
14889 prepare_response: wire_cst_prepare_ln_url_pay_response,
14890 }
14891 #[repr(C)]
14892 #[derive(Clone, Copy)]
14893 pub struct wire_cst_ln_url_pay_request_data {
14894 callback: *mut wire_cst_list_prim_u_8_strict,
14895 min_sendable: u64,
14896 max_sendable: u64,
14897 metadata_str: *mut wire_cst_list_prim_u_8_strict,
14898 comment_allowed: u16,
14899 domain: *mut wire_cst_list_prim_u_8_strict,
14900 allows_nostr: bool,
14901 nostr_pubkey: *mut wire_cst_list_prim_u_8_strict,
14902 ln_address: *mut wire_cst_list_prim_u_8_strict,
14903 }
14904 #[repr(C)]
14905 #[derive(Clone, Copy)]
14906 pub struct wire_cst_ln_url_pay_result {
14907 tag: i32,
14908 kind: LnUrlPayResultKind,
14909 }
14910 #[repr(C)]
14911 #[derive(Clone, Copy)]
14912 pub union LnUrlPayResultKind {
14913 EndpointSuccess: wire_cst_LnUrlPayResult_EndpointSuccess,
14914 EndpointError: wire_cst_LnUrlPayResult_EndpointError,
14915 PayError: wire_cst_LnUrlPayResult_PayError,
14916 nil__: (),
14917 }
14918 #[repr(C)]
14919 #[derive(Clone, Copy)]
14920 pub struct wire_cst_LnUrlPayResult_EndpointSuccess {
14921 data: *mut wire_cst_ln_url_pay_success_data,
14922 }
14923 #[repr(C)]
14924 #[derive(Clone, Copy)]
14925 pub struct wire_cst_LnUrlPayResult_EndpointError {
14926 data: *mut wire_cst_ln_url_error_data,
14927 }
14928 #[repr(C)]
14929 #[derive(Clone, Copy)]
14930 pub struct wire_cst_LnUrlPayResult_PayError {
14931 data: *mut wire_cst_ln_url_pay_error_data,
14932 }
14933 #[repr(C)]
14934 #[derive(Clone, Copy)]
14935 pub struct wire_cst_ln_url_pay_success_data {
14936 payment: wire_cst_payment,
14937 success_action: *mut wire_cst_success_action_processed,
14938 }
14939 #[repr(C)]
14940 #[derive(Clone, Copy)]
14941 pub struct wire_cst_ln_url_withdraw_error {
14942 tag: i32,
14943 kind: LnUrlWithdrawErrorKind,
14944 }
14945 #[repr(C)]
14946 #[derive(Clone, Copy)]
14947 pub union LnUrlWithdrawErrorKind {
14948 Generic: wire_cst_LnUrlWithdrawError_Generic,
14949 InvalidAmount: wire_cst_LnUrlWithdrawError_InvalidAmount,
14950 InvalidInvoice: wire_cst_LnUrlWithdrawError_InvalidInvoice,
14951 InvalidUri: wire_cst_LnUrlWithdrawError_InvalidUri,
14952 InvoiceNoRoutingHints: wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints,
14953 ServiceConnectivity: wire_cst_LnUrlWithdrawError_ServiceConnectivity,
14954 nil__: (),
14955 }
14956 #[repr(C)]
14957 #[derive(Clone, Copy)]
14958 pub struct wire_cst_LnUrlWithdrawError_Generic {
14959 err: *mut wire_cst_list_prim_u_8_strict,
14960 }
14961 #[repr(C)]
14962 #[derive(Clone, Copy)]
14963 pub struct wire_cst_LnUrlWithdrawError_InvalidAmount {
14964 err: *mut wire_cst_list_prim_u_8_strict,
14965 }
14966 #[repr(C)]
14967 #[derive(Clone, Copy)]
14968 pub struct wire_cst_LnUrlWithdrawError_InvalidInvoice {
14969 err: *mut wire_cst_list_prim_u_8_strict,
14970 }
14971 #[repr(C)]
14972 #[derive(Clone, Copy)]
14973 pub struct wire_cst_LnUrlWithdrawError_InvalidUri {
14974 err: *mut wire_cst_list_prim_u_8_strict,
14975 }
14976 #[repr(C)]
14977 #[derive(Clone, Copy)]
14978 pub struct wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints {
14979 err: *mut wire_cst_list_prim_u_8_strict,
14980 }
14981 #[repr(C)]
14982 #[derive(Clone, Copy)]
14983 pub struct wire_cst_LnUrlWithdrawError_ServiceConnectivity {
14984 err: *mut wire_cst_list_prim_u_8_strict,
14985 }
14986 #[repr(C)]
14987 #[derive(Clone, Copy)]
14988 pub struct wire_cst_ln_url_withdraw_request {
14989 data: wire_cst_ln_url_withdraw_request_data,
14990 amount_msat: u64,
14991 description: *mut wire_cst_list_prim_u_8_strict,
14992 }
14993 #[repr(C)]
14994 #[derive(Clone, Copy)]
14995 pub struct wire_cst_ln_url_withdraw_request_data {
14996 callback: *mut wire_cst_list_prim_u_8_strict,
14997 k1: *mut wire_cst_list_prim_u_8_strict,
14998 default_description: *mut wire_cst_list_prim_u_8_strict,
14999 min_withdrawable: u64,
15000 max_withdrawable: u64,
15001 }
15002 #[repr(C)]
15003 #[derive(Clone, Copy)]
15004 pub struct wire_cst_ln_url_withdraw_result {
15005 tag: i32,
15006 kind: LnUrlWithdrawResultKind,
15007 }
15008 #[repr(C)]
15009 #[derive(Clone, Copy)]
15010 pub union LnUrlWithdrawResultKind {
15011 Ok: wire_cst_LnUrlWithdrawResult_Ok,
15012 Timeout: wire_cst_LnUrlWithdrawResult_Timeout,
15013 ErrorStatus: wire_cst_LnUrlWithdrawResult_ErrorStatus,
15014 nil__: (),
15015 }
15016 #[repr(C)]
15017 #[derive(Clone, Copy)]
15018 pub struct wire_cst_LnUrlWithdrawResult_Ok {
15019 data: *mut wire_cst_ln_url_withdraw_success_data,
15020 }
15021 #[repr(C)]
15022 #[derive(Clone, Copy)]
15023 pub struct wire_cst_LnUrlWithdrawResult_Timeout {
15024 data: *mut wire_cst_ln_url_withdraw_success_data,
15025 }
15026 #[repr(C)]
15027 #[derive(Clone, Copy)]
15028 pub struct wire_cst_LnUrlWithdrawResult_ErrorStatus {
15029 data: *mut wire_cst_ln_url_error_data,
15030 }
15031 #[repr(C)]
15032 #[derive(Clone, Copy)]
15033 pub struct wire_cst_ln_url_withdraw_success_data {
15034 invoice: wire_cst_ln_invoice,
15035 }
15036 #[repr(C)]
15037 #[derive(Clone, Copy)]
15038 pub struct wire_cst_locale_overrides {
15039 locale: *mut wire_cst_list_prim_u_8_strict,
15040 spacing: *mut u32,
15041 symbol: wire_cst_symbol,
15042 }
15043 #[repr(C)]
15044 #[derive(Clone, Copy)]
15045 pub struct wire_cst_localized_name {
15046 locale: *mut wire_cst_list_prim_u_8_strict,
15047 name: *mut wire_cst_list_prim_u_8_strict,
15048 }
15049 #[repr(C)]
15050 #[derive(Clone, Copy)]
15051 pub struct wire_cst_log_entry {
15052 line: *mut wire_cst_list_prim_u_8_strict,
15053 level: *mut wire_cst_list_prim_u_8_strict,
15054 }
15055 #[repr(C)]
15056 #[derive(Clone, Copy)]
15057 pub struct wire_cst_message_success_action_data {
15058 message: *mut wire_cst_list_prim_u_8_strict,
15059 }
15060 #[repr(C)]
15061 #[derive(Clone, Copy)]
15062 pub struct wire_cst_onchain_payment_limits_response {
15063 send: wire_cst_limits,
15064 receive: wire_cst_limits,
15065 }
15066 #[repr(C)]
15067 #[derive(Clone, Copy)]
15068 pub struct wire_cst_pay_amount {
15069 tag: i32,
15070 kind: PayAmountKind,
15071 }
15072 #[repr(C)]
15073 #[derive(Clone, Copy)]
15074 pub union PayAmountKind {
15075 Bitcoin: wire_cst_PayAmount_Bitcoin,
15076 Asset: wire_cst_PayAmount_Asset,
15077 nil__: (),
15078 }
15079 #[repr(C)]
15080 #[derive(Clone, Copy)]
15081 pub struct wire_cst_PayAmount_Bitcoin {
15082 receiver_amount_sat: u64,
15083 }
15084 #[repr(C)]
15085 #[derive(Clone, Copy)]
15086 pub struct wire_cst_PayAmount_Asset {
15087 to_asset: *mut wire_cst_list_prim_u_8_strict,
15088 receiver_amount: f64,
15089 estimate_asset_fees: *mut bool,
15090 from_asset: *mut wire_cst_list_prim_u_8_strict,
15091 }
15092 #[repr(C)]
15093 #[derive(Clone, Copy)]
15094 pub struct wire_cst_pay_onchain_request {
15095 address: *mut wire_cst_list_prim_u_8_strict,
15096 prepare_response: wire_cst_prepare_pay_onchain_response,
15097 }
15098 #[repr(C)]
15099 #[derive(Clone, Copy)]
15100 pub struct wire_cst_payment {
15101 destination: *mut wire_cst_list_prim_u_8_strict,
15102 tx_id: *mut wire_cst_list_prim_u_8_strict,
15103 unblinding_data: *mut wire_cst_list_prim_u_8_strict,
15104 timestamp: u32,
15105 amount_sat: u64,
15106 fees_sat: u64,
15107 swapper_fees_sat: *mut u64,
15108 payment_type: i32,
15109 status: i32,
15110 details: wire_cst_payment_details,
15111 }
15112 #[repr(C)]
15113 #[derive(Clone, Copy)]
15114 pub struct wire_cst_payment_details {
15115 tag: i32,
15116 kind: PaymentDetailsKind,
15117 }
15118 #[repr(C)]
15119 #[derive(Clone, Copy)]
15120 pub union PaymentDetailsKind {
15121 Lightning: wire_cst_PaymentDetails_Lightning,
15122 Liquid: wire_cst_PaymentDetails_Liquid,
15123 Bitcoin: wire_cst_PaymentDetails_Bitcoin,
15124 nil__: (),
15125 }
15126 #[repr(C)]
15127 #[derive(Clone, Copy)]
15128 pub struct wire_cst_PaymentDetails_Lightning {
15129 swap_id: *mut wire_cst_list_prim_u_8_strict,
15130 description: *mut wire_cst_list_prim_u_8_strict,
15131 liquid_expiration_blockheight: u32,
15132 preimage: *mut wire_cst_list_prim_u_8_strict,
15133 invoice: *mut wire_cst_list_prim_u_8_strict,
15134 bolt12_offer: *mut wire_cst_list_prim_u_8_strict,
15135 payment_hash: *mut wire_cst_list_prim_u_8_strict,
15136 destination_pubkey: *mut wire_cst_list_prim_u_8_strict,
15137 lnurl_info: *mut wire_cst_ln_url_info,
15138 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15139 payer_note: *mut wire_cst_list_prim_u_8_strict,
15140 claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15141 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15142 refund_tx_amount_sat: *mut u64,
15143 }
15144 #[repr(C)]
15145 #[derive(Clone, Copy)]
15146 pub struct wire_cst_PaymentDetails_Liquid {
15147 destination: *mut wire_cst_list_prim_u_8_strict,
15148 description: *mut wire_cst_list_prim_u_8_strict,
15149 asset_id: *mut wire_cst_list_prim_u_8_strict,
15150 asset_info: *mut wire_cst_asset_info,
15151 lnurl_info: *mut wire_cst_ln_url_info,
15152 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15153 payer_note: *mut wire_cst_list_prim_u_8_strict,
15154 }
15155 #[repr(C)]
15156 #[derive(Clone, Copy)]
15157 pub struct wire_cst_PaymentDetails_Bitcoin {
15158 swap_id: *mut wire_cst_list_prim_u_8_strict,
15159 bitcoin_address: *mut wire_cst_list_prim_u_8_strict,
15160 description: *mut wire_cst_list_prim_u_8_strict,
15161 auto_accepted_fees: bool,
15162 liquid_expiration_blockheight: *mut u32,
15163 bitcoin_expiration_blockheight: *mut u32,
15164 lockup_tx_id: *mut wire_cst_list_prim_u_8_strict,
15165 claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15166 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15167 refund_tx_amount_sat: *mut u64,
15168 }
15169 #[repr(C)]
15170 #[derive(Clone, Copy)]
15171 pub struct wire_cst_payment_error {
15172 tag: i32,
15173 kind: PaymentErrorKind,
15174 }
15175 #[repr(C)]
15176 #[derive(Clone, Copy)]
15177 pub union PaymentErrorKind {
15178 AmountOutOfRange: wire_cst_PaymentError_AmountOutOfRange,
15179 AmountMissing: wire_cst_PaymentError_AmountMissing,
15180 AssetError: wire_cst_PaymentError_AssetError,
15181 InvalidNetwork: wire_cst_PaymentError_InvalidNetwork,
15182 Generic: wire_cst_PaymentError_Generic,
15183 InvalidDescription: wire_cst_PaymentError_InvalidDescription,
15184 InvalidInvoice: wire_cst_PaymentError_InvalidInvoice,
15185 ReceiveError: wire_cst_PaymentError_ReceiveError,
15186 Refunded: wire_cst_PaymentError_Refunded,
15187 SendError: wire_cst_PaymentError_SendError,
15188 SignerError: wire_cst_PaymentError_SignerError,
15189 nil__: (),
15190 }
15191 #[repr(C)]
15192 #[derive(Clone, Copy)]
15193 pub struct wire_cst_PaymentError_AmountOutOfRange {
15194 min: u64,
15195 max: u64,
15196 }
15197 #[repr(C)]
15198 #[derive(Clone, Copy)]
15199 pub struct wire_cst_PaymentError_AmountMissing {
15200 err: *mut wire_cst_list_prim_u_8_strict,
15201 }
15202 #[repr(C)]
15203 #[derive(Clone, Copy)]
15204 pub struct wire_cst_PaymentError_AssetError {
15205 err: *mut wire_cst_list_prim_u_8_strict,
15206 }
15207 #[repr(C)]
15208 #[derive(Clone, Copy)]
15209 pub struct wire_cst_PaymentError_InvalidNetwork {
15210 err: *mut wire_cst_list_prim_u_8_strict,
15211 }
15212 #[repr(C)]
15213 #[derive(Clone, Copy)]
15214 pub struct wire_cst_PaymentError_Generic {
15215 err: *mut wire_cst_list_prim_u_8_strict,
15216 }
15217 #[repr(C)]
15218 #[derive(Clone, Copy)]
15219 pub struct wire_cst_PaymentError_InvalidDescription {
15220 err: *mut wire_cst_list_prim_u_8_strict,
15221 }
15222 #[repr(C)]
15223 #[derive(Clone, Copy)]
15224 pub struct wire_cst_PaymentError_InvalidInvoice {
15225 err: *mut wire_cst_list_prim_u_8_strict,
15226 }
15227 #[repr(C)]
15228 #[derive(Clone, Copy)]
15229 pub struct wire_cst_PaymentError_ReceiveError {
15230 err: *mut wire_cst_list_prim_u_8_strict,
15231 }
15232 #[repr(C)]
15233 #[derive(Clone, Copy)]
15234 pub struct wire_cst_PaymentError_Refunded {
15235 err: *mut wire_cst_list_prim_u_8_strict,
15236 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15237 }
15238 #[repr(C)]
15239 #[derive(Clone, Copy)]
15240 pub struct wire_cst_PaymentError_SendError {
15241 err: *mut wire_cst_list_prim_u_8_strict,
15242 }
15243 #[repr(C)]
15244 #[derive(Clone, Copy)]
15245 pub struct wire_cst_PaymentError_SignerError {
15246 err: *mut wire_cst_list_prim_u_8_strict,
15247 }
15248 #[repr(C)]
15249 #[derive(Clone, Copy)]
15250 pub struct wire_cst_prepare_buy_bitcoin_request {
15251 provider: i32,
15252 amount_sat: u64,
15253 }
15254 #[repr(C)]
15255 #[derive(Clone, Copy)]
15256 pub struct wire_cst_prepare_buy_bitcoin_response {
15257 provider: i32,
15258 amount_sat: u64,
15259 fees_sat: u64,
15260 }
15261 #[repr(C)]
15262 #[derive(Clone, Copy)]
15263 pub struct wire_cst_prepare_ln_url_pay_request {
15264 data: wire_cst_ln_url_pay_request_data,
15265 amount: wire_cst_pay_amount,
15266 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15267 comment: *mut wire_cst_list_prim_u_8_strict,
15268 validate_success_action_url: *mut bool,
15269 }
15270 #[repr(C)]
15271 #[derive(Clone, Copy)]
15272 pub struct wire_cst_prepare_ln_url_pay_response {
15273 destination: wire_cst_send_destination,
15274 fees_sat: u64,
15275 data: wire_cst_ln_url_pay_request_data,
15276 amount: wire_cst_pay_amount,
15277 comment: *mut wire_cst_list_prim_u_8_strict,
15278 success_action: *mut wire_cst_success_action,
15279 }
15280 #[repr(C)]
15281 #[derive(Clone, Copy)]
15282 pub struct wire_cst_prepare_pay_onchain_request {
15283 amount: wire_cst_pay_amount,
15284 fee_rate_sat_per_vbyte: *mut u32,
15285 }
15286 #[repr(C)]
15287 #[derive(Clone, Copy)]
15288 pub struct wire_cst_prepare_pay_onchain_response {
15289 receiver_amount_sat: u64,
15290 claim_fees_sat: u64,
15291 total_fees_sat: u64,
15292 }
15293 #[repr(C)]
15294 #[derive(Clone, Copy)]
15295 pub struct wire_cst_prepare_receive_request {
15296 payment_method: i32,
15297 amount: *mut wire_cst_receive_amount,
15298 }
15299 #[repr(C)]
15300 #[derive(Clone, Copy)]
15301 pub struct wire_cst_prepare_receive_response {
15302 payment_method: i32,
15303 fees_sat: u64,
15304 amount: *mut wire_cst_receive_amount,
15305 min_payer_amount_sat: *mut u64,
15306 max_payer_amount_sat: *mut u64,
15307 swapper_feerate: *mut f64,
15308 }
15309 #[repr(C)]
15310 #[derive(Clone, Copy)]
15311 pub struct wire_cst_prepare_refund_request {
15312 swap_address: *mut wire_cst_list_prim_u_8_strict,
15313 refund_address: *mut wire_cst_list_prim_u_8_strict,
15314 fee_rate_sat_per_vbyte: u32,
15315 }
15316 #[repr(C)]
15317 #[derive(Clone, Copy)]
15318 pub struct wire_cst_prepare_refund_response {
15319 tx_vsize: u32,
15320 tx_fee_sat: u64,
15321 last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15322 }
15323 #[repr(C)]
15324 #[derive(Clone, Copy)]
15325 pub struct wire_cst_prepare_send_request {
15326 destination: *mut wire_cst_list_prim_u_8_strict,
15327 amount: *mut wire_cst_pay_amount,
15328 }
15329 #[repr(C)]
15330 #[derive(Clone, Copy)]
15331 pub struct wire_cst_prepare_send_response {
15332 destination: wire_cst_send_destination,
15333 amount: *mut wire_cst_pay_amount,
15334 fees_sat: *mut u64,
15335 estimated_asset_fees: *mut f64,
15336 exchange_amount_sat: *mut u64,
15337 }
15338 #[repr(C)]
15339 #[derive(Clone, Copy)]
15340 pub struct wire_cst_rate {
15341 coin: *mut wire_cst_list_prim_u_8_strict,
15342 value: f64,
15343 }
15344 #[repr(C)]
15345 #[derive(Clone, Copy)]
15346 pub struct wire_cst_receive_amount {
15347 tag: i32,
15348 kind: ReceiveAmountKind,
15349 }
15350 #[repr(C)]
15351 #[derive(Clone, Copy)]
15352 pub union ReceiveAmountKind {
15353 Bitcoin: wire_cst_ReceiveAmount_Bitcoin,
15354 Asset: wire_cst_ReceiveAmount_Asset,
15355 nil__: (),
15356 }
15357 #[repr(C)]
15358 #[derive(Clone, Copy)]
15359 pub struct wire_cst_ReceiveAmount_Bitcoin {
15360 payer_amount_sat: u64,
15361 }
15362 #[repr(C)]
15363 #[derive(Clone, Copy)]
15364 pub struct wire_cst_ReceiveAmount_Asset {
15365 asset_id: *mut wire_cst_list_prim_u_8_strict,
15366 payer_amount: *mut f64,
15367 }
15368 #[repr(C)]
15369 #[derive(Clone, Copy)]
15370 pub struct wire_cst_receive_payment_request {
15371 prepare_response: wire_cst_prepare_receive_response,
15372 description: *mut wire_cst_list_prim_u_8_strict,
15373 use_description_hash: *mut bool,
15374 payer_note: *mut wire_cst_list_prim_u_8_strict,
15375 }
15376 #[repr(C)]
15377 #[derive(Clone, Copy)]
15378 pub struct wire_cst_receive_payment_response {
15379 destination: *mut wire_cst_list_prim_u_8_strict,
15380 }
15381 #[repr(C)]
15382 #[derive(Clone, Copy)]
15383 pub struct wire_cst_recommended_fees {
15384 fastest_fee: u64,
15385 half_hour_fee: u64,
15386 hour_fee: u64,
15387 economy_fee: u64,
15388 minimum_fee: u64,
15389 }
15390 #[repr(C)]
15391 #[derive(Clone, Copy)]
15392 pub struct wire_cst_refund_request {
15393 swap_address: *mut wire_cst_list_prim_u_8_strict,
15394 refund_address: *mut wire_cst_list_prim_u_8_strict,
15395 fee_rate_sat_per_vbyte: u32,
15396 }
15397 #[repr(C)]
15398 #[derive(Clone, Copy)]
15399 pub struct wire_cst_refund_response {
15400 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15401 }
15402 #[repr(C)]
15403 #[derive(Clone, Copy)]
15404 pub struct wire_cst_refundable_swap {
15405 swap_address: *mut wire_cst_list_prim_u_8_strict,
15406 timestamp: u32,
15407 amount_sat: u64,
15408 last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15409 }
15410 #[repr(C)]
15411 #[derive(Clone, Copy)]
15412 pub struct wire_cst_restore_request {
15413 backup_path: *mut wire_cst_list_prim_u_8_strict,
15414 }
15415 #[repr(C)]
15416 #[derive(Clone, Copy)]
15417 pub struct wire_cst_route_hint {
15418 hops: *mut wire_cst_list_route_hint_hop,
15419 }
15420 #[repr(C)]
15421 #[derive(Clone, Copy)]
15422 pub struct wire_cst_route_hint_hop {
15423 src_node_id: *mut wire_cst_list_prim_u_8_strict,
15424 short_channel_id: *mut wire_cst_list_prim_u_8_strict,
15425 fees_base_msat: u32,
15426 fees_proportional_millionths: u32,
15427 cltv_expiry_delta: u64,
15428 htlc_minimum_msat: *mut u64,
15429 htlc_maximum_msat: *mut u64,
15430 }
15431 #[repr(C)]
15432 #[derive(Clone, Copy)]
15433 pub struct wire_cst_sdk_error {
15434 tag: i32,
15435 kind: SdkErrorKind,
15436 }
15437 #[repr(C)]
15438 #[derive(Clone, Copy)]
15439 pub union SdkErrorKind {
15440 Generic: wire_cst_SdkError_Generic,
15441 ServiceConnectivity: wire_cst_SdkError_ServiceConnectivity,
15442 nil__: (),
15443 }
15444 #[repr(C)]
15445 #[derive(Clone, Copy)]
15446 pub struct wire_cst_SdkError_Generic {
15447 err: *mut wire_cst_list_prim_u_8_strict,
15448 }
15449 #[repr(C)]
15450 #[derive(Clone, Copy)]
15451 pub struct wire_cst_SdkError_ServiceConnectivity {
15452 err: *mut wire_cst_list_prim_u_8_strict,
15453 }
15454 #[repr(C)]
15455 #[derive(Clone, Copy)]
15456 pub struct wire_cst_sdk_event {
15457 tag: i32,
15458 kind: SdkEventKind,
15459 }
15460 #[repr(C)]
15461 #[derive(Clone, Copy)]
15462 pub union SdkEventKind {
15463 PaymentFailed: wire_cst_SdkEvent_PaymentFailed,
15464 PaymentPending: wire_cst_SdkEvent_PaymentPending,
15465 PaymentRefundable: wire_cst_SdkEvent_PaymentRefundable,
15466 PaymentRefunded: wire_cst_SdkEvent_PaymentRefunded,
15467 PaymentRefundPending: wire_cst_SdkEvent_PaymentRefundPending,
15468 PaymentSucceeded: wire_cst_SdkEvent_PaymentSucceeded,
15469 PaymentWaitingConfirmation: wire_cst_SdkEvent_PaymentWaitingConfirmation,
15470 PaymentWaitingFeeAcceptance: wire_cst_SdkEvent_PaymentWaitingFeeAcceptance,
15471 DataSynced: wire_cst_SdkEvent_DataSynced,
15472 nil__: (),
15473 }
15474 #[repr(C)]
15475 #[derive(Clone, Copy)]
15476 pub struct wire_cst_SdkEvent_PaymentFailed {
15477 details: *mut wire_cst_payment,
15478 }
15479 #[repr(C)]
15480 #[derive(Clone, Copy)]
15481 pub struct wire_cst_SdkEvent_PaymentPending {
15482 details: *mut wire_cst_payment,
15483 }
15484 #[repr(C)]
15485 #[derive(Clone, Copy)]
15486 pub struct wire_cst_SdkEvent_PaymentRefundable {
15487 details: *mut wire_cst_payment,
15488 }
15489 #[repr(C)]
15490 #[derive(Clone, Copy)]
15491 pub struct wire_cst_SdkEvent_PaymentRefunded {
15492 details: *mut wire_cst_payment,
15493 }
15494 #[repr(C)]
15495 #[derive(Clone, Copy)]
15496 pub struct wire_cst_SdkEvent_PaymentRefundPending {
15497 details: *mut wire_cst_payment,
15498 }
15499 #[repr(C)]
15500 #[derive(Clone, Copy)]
15501 pub struct wire_cst_SdkEvent_PaymentSucceeded {
15502 details: *mut wire_cst_payment,
15503 }
15504 #[repr(C)]
15505 #[derive(Clone, Copy)]
15506 pub struct wire_cst_SdkEvent_PaymentWaitingConfirmation {
15507 details: *mut wire_cst_payment,
15508 }
15509 #[repr(C)]
15510 #[derive(Clone, Copy)]
15511 pub struct wire_cst_SdkEvent_PaymentWaitingFeeAcceptance {
15512 details: *mut wire_cst_payment,
15513 }
15514 #[repr(C)]
15515 #[derive(Clone, Copy)]
15516 pub struct wire_cst_SdkEvent_DataSynced {
15517 did_pull_new_records: bool,
15518 }
15519 #[repr(C)]
15520 #[derive(Clone, Copy)]
15521 pub struct wire_cst_send_destination {
15522 tag: i32,
15523 kind: SendDestinationKind,
15524 }
15525 #[repr(C)]
15526 #[derive(Clone, Copy)]
15527 pub union SendDestinationKind {
15528 LiquidAddress: wire_cst_SendDestination_LiquidAddress,
15529 Bolt11: wire_cst_SendDestination_Bolt11,
15530 Bolt12: wire_cst_SendDestination_Bolt12,
15531 nil__: (),
15532 }
15533 #[repr(C)]
15534 #[derive(Clone, Copy)]
15535 pub struct wire_cst_SendDestination_LiquidAddress {
15536 address_data: *mut wire_cst_liquid_address_data,
15537 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15538 }
15539 #[repr(C)]
15540 #[derive(Clone, Copy)]
15541 pub struct wire_cst_SendDestination_Bolt11 {
15542 invoice: *mut wire_cst_ln_invoice,
15543 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15544 }
15545 #[repr(C)]
15546 #[derive(Clone, Copy)]
15547 pub struct wire_cst_SendDestination_Bolt12 {
15548 offer: *mut wire_cst_ln_offer,
15549 receiver_amount_sat: u64,
15550 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15551 }
15552 #[repr(C)]
15553 #[derive(Clone, Copy)]
15554 pub struct wire_cst_send_payment_request {
15555 prepare_response: wire_cst_prepare_send_response,
15556 use_asset_fees: *mut bool,
15557 payer_note: *mut wire_cst_list_prim_u_8_strict,
15558 }
15559 #[repr(C)]
15560 #[derive(Clone, Copy)]
15561 pub struct wire_cst_send_payment_response {
15562 payment: wire_cst_payment,
15563 }
15564 #[repr(C)]
15565 #[derive(Clone, Copy)]
15566 pub struct wire_cst_sign_message_request {
15567 message: *mut wire_cst_list_prim_u_8_strict,
15568 }
15569 #[repr(C)]
15570 #[derive(Clone, Copy)]
15571 pub struct wire_cst_sign_message_response {
15572 signature: *mut wire_cst_list_prim_u_8_strict,
15573 }
15574 #[repr(C)]
15575 #[derive(Clone, Copy)]
15576 pub struct wire_cst_success_action {
15577 tag: i32,
15578 kind: SuccessActionKind,
15579 }
15580 #[repr(C)]
15581 #[derive(Clone, Copy)]
15582 pub union SuccessActionKind {
15583 Aes: wire_cst_SuccessAction_Aes,
15584 Message: wire_cst_SuccessAction_Message,
15585 Url: wire_cst_SuccessAction_Url,
15586 nil__: (),
15587 }
15588 #[repr(C)]
15589 #[derive(Clone, Copy)]
15590 pub struct wire_cst_SuccessAction_Aes {
15591 data: *mut wire_cst_aes_success_action_data,
15592 }
15593 #[repr(C)]
15594 #[derive(Clone, Copy)]
15595 pub struct wire_cst_SuccessAction_Message {
15596 data: *mut wire_cst_message_success_action_data,
15597 }
15598 #[repr(C)]
15599 #[derive(Clone, Copy)]
15600 pub struct wire_cst_SuccessAction_Url {
15601 data: *mut wire_cst_url_success_action_data,
15602 }
15603 #[repr(C)]
15604 #[derive(Clone, Copy)]
15605 pub struct wire_cst_success_action_processed {
15606 tag: i32,
15607 kind: SuccessActionProcessedKind,
15608 }
15609 #[repr(C)]
15610 #[derive(Clone, Copy)]
15611 pub union SuccessActionProcessedKind {
15612 Aes: wire_cst_SuccessActionProcessed_Aes,
15613 Message: wire_cst_SuccessActionProcessed_Message,
15614 Url: wire_cst_SuccessActionProcessed_Url,
15615 nil__: (),
15616 }
15617 #[repr(C)]
15618 #[derive(Clone, Copy)]
15619 pub struct wire_cst_SuccessActionProcessed_Aes {
15620 result: *mut wire_cst_aes_success_action_data_result,
15621 }
15622 #[repr(C)]
15623 #[derive(Clone, Copy)]
15624 pub struct wire_cst_SuccessActionProcessed_Message {
15625 data: *mut wire_cst_message_success_action_data,
15626 }
15627 #[repr(C)]
15628 #[derive(Clone, Copy)]
15629 pub struct wire_cst_SuccessActionProcessed_Url {
15630 data: *mut wire_cst_url_success_action_data,
15631 }
15632 #[repr(C)]
15633 #[derive(Clone, Copy)]
15634 pub struct wire_cst_symbol {
15635 grapheme: *mut wire_cst_list_prim_u_8_strict,
15636 template: *mut wire_cst_list_prim_u_8_strict,
15637 rtl: *mut bool,
15638 position: *mut u32,
15639 }
15640 #[repr(C)]
15641 #[derive(Clone, Copy)]
15642 pub struct wire_cst_url_success_action_data {
15643 description: *mut wire_cst_list_prim_u_8_strict,
15644 url: *mut wire_cst_list_prim_u_8_strict,
15645 matches_callback_domain: bool,
15646 }
15647 #[repr(C)]
15648 #[derive(Clone, Copy)]
15649 pub struct wire_cst_wallet_info {
15650 balance_sat: u64,
15651 pending_send_sat: u64,
15652 pending_receive_sat: u64,
15653 fingerprint: *mut wire_cst_list_prim_u_8_strict,
15654 pubkey: *mut wire_cst_list_prim_u_8_strict,
15655 asset_balances: *mut wire_cst_list_asset_balance,
15656 }
15657}
15658#[cfg(not(target_family = "wasm"))]
15659pub use io::*;