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 return crate::model::Config {
2644 liquid_explorer: var_liquidExplorer,
2645 bitcoin_explorer: var_bitcoinExplorer,
2646 working_dir: var_workingDir,
2647 network: var_network,
2648 payment_timeout_sec: var_paymentTimeoutSec,
2649 sync_service_url: var_syncServiceUrl,
2650 zero_conf_max_amount_sat: var_zeroConfMaxAmountSat,
2651 breez_api_key: var_breezApiKey,
2652 external_input_parsers: var_externalInputParsers,
2653 use_default_external_input_parsers: var_useDefaultExternalInputParsers,
2654 onchain_fee_rate_leeway_sat: var_onchainFeeRateLeewaySat,
2655 asset_metadata: var_assetMetadata,
2656 sideswap_api_key: var_sideswapApiKey,
2657 };
2658 }
2659}
2660
2661impl SseDecode for crate::model::ConnectRequest {
2662 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2664 let mut var_config = <crate::model::Config>::sse_decode(deserializer);
2665 let mut var_mnemonic = <Option<String>>::sse_decode(deserializer);
2666 let mut var_passphrase = <Option<String>>::sse_decode(deserializer);
2667 let mut var_seed = <Option<Vec<u8>>>::sse_decode(deserializer);
2668 return crate::model::ConnectRequest {
2669 config: var_config,
2670 mnemonic: var_mnemonic,
2671 passphrase: var_passphrase,
2672 seed: var_seed,
2673 };
2674 }
2675}
2676
2677impl SseDecode for crate::model::CreateBolt12InvoiceRequest {
2678 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2680 let mut var_offer = <String>::sse_decode(deserializer);
2681 let mut var_invoiceRequest = <String>::sse_decode(deserializer);
2682 return crate::model::CreateBolt12InvoiceRequest {
2683 offer: var_offer,
2684 invoice_request: var_invoiceRequest,
2685 };
2686 }
2687}
2688
2689impl SseDecode for crate::model::CreateBolt12InvoiceResponse {
2690 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2692 let mut var_invoice = <String>::sse_decode(deserializer);
2693 return crate::model::CreateBolt12InvoiceResponse {
2694 invoice: var_invoice,
2695 };
2696 }
2697}
2698
2699impl SseDecode for crate::bindings::CurrencyInfo {
2700 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2702 let mut var_name = <String>::sse_decode(deserializer);
2703 let mut var_fractionSize = <u32>::sse_decode(deserializer);
2704 let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
2705 let mut var_symbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2706 let mut var_uniqSymbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2707 let mut var_localizedName = <Vec<crate::bindings::LocalizedName>>::sse_decode(deserializer);
2708 let mut var_localeOverrides =
2709 <Vec<crate::bindings::LocaleOverrides>>::sse_decode(deserializer);
2710 return crate::bindings::CurrencyInfo {
2711 name: var_name,
2712 fraction_size: var_fractionSize,
2713 spacing: var_spacing,
2714 symbol: var_symbol,
2715 uniq_symbol: var_uniqSymbol,
2716 localized_name: var_localizedName,
2717 locale_overrides: var_localeOverrides,
2718 };
2719 }
2720}
2721
2722impl SseDecode for crate::bindings::ExternalInputParser {
2723 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2725 let mut var_providerId = <String>::sse_decode(deserializer);
2726 let mut var_inputRegex = <String>::sse_decode(deserializer);
2727 let mut var_parserUrl = <String>::sse_decode(deserializer);
2728 return crate::bindings::ExternalInputParser {
2729 provider_id: var_providerId,
2730 input_regex: var_inputRegex,
2731 parser_url: var_parserUrl,
2732 };
2733 }
2734}
2735
2736impl SseDecode for f64 {
2737 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2739 deserializer.cursor.read_f64::<NativeEndian>().unwrap()
2740 }
2741}
2742
2743impl SseDecode for crate::model::FetchPaymentProposedFeesRequest {
2744 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2746 let mut var_swapId = <String>::sse_decode(deserializer);
2747 return crate::model::FetchPaymentProposedFeesRequest {
2748 swap_id: var_swapId,
2749 };
2750 }
2751}
2752
2753impl SseDecode for crate::model::FetchPaymentProposedFeesResponse {
2754 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2756 let mut var_swapId = <String>::sse_decode(deserializer);
2757 let mut var_feesSat = <u64>::sse_decode(deserializer);
2758 let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
2759 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
2760 return crate::model::FetchPaymentProposedFeesResponse {
2761 swap_id: var_swapId,
2762 fees_sat: var_feesSat,
2763 payer_amount_sat: var_payerAmountSat,
2764 receiver_amount_sat: var_receiverAmountSat,
2765 };
2766 }
2767}
2768
2769impl SseDecode for crate::bindings::FiatCurrency {
2770 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2772 let mut var_id = <String>::sse_decode(deserializer);
2773 let mut var_info = <crate::bindings::CurrencyInfo>::sse_decode(deserializer);
2774 return crate::bindings::FiatCurrency {
2775 id: var_id,
2776 info: var_info,
2777 };
2778 }
2779}
2780
2781impl SseDecode for crate::model::GetInfoResponse {
2782 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2784 let mut var_walletInfo = <crate::model::WalletInfo>::sse_decode(deserializer);
2785 let mut var_blockchainInfo = <crate::model::BlockchainInfo>::sse_decode(deserializer);
2786 return crate::model::GetInfoResponse {
2787 wallet_info: var_walletInfo,
2788 blockchain_info: var_blockchainInfo,
2789 };
2790 }
2791}
2792
2793impl SseDecode for crate::model::GetPaymentRequest {
2794 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2796 let mut tag_ = <i32>::sse_decode(deserializer);
2797 match tag_ {
2798 0 => {
2799 let mut var_paymentHash = <String>::sse_decode(deserializer);
2800 return crate::model::GetPaymentRequest::PaymentHash {
2801 payment_hash: var_paymentHash,
2802 };
2803 }
2804 1 => {
2805 let mut var_swapId = <String>::sse_decode(deserializer);
2806 return crate::model::GetPaymentRequest::SwapId {
2807 swap_id: var_swapId,
2808 };
2809 }
2810 _ => {
2811 unimplemented!("");
2812 }
2813 }
2814 }
2815}
2816
2817impl SseDecode for i32 {
2818 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2820 deserializer.cursor.read_i32::<NativeEndian>().unwrap()
2821 }
2822}
2823
2824impl SseDecode for i64 {
2825 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2827 deserializer.cursor.read_i64::<NativeEndian>().unwrap()
2828 }
2829}
2830
2831impl SseDecode for crate::bindings::InputType {
2832 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2834 let mut tag_ = <i32>::sse_decode(deserializer);
2835 match tag_ {
2836 0 => {
2837 let mut var_address =
2838 <crate::bindings::BitcoinAddressData>::sse_decode(deserializer);
2839 return crate::bindings::InputType::BitcoinAddress {
2840 address: var_address,
2841 };
2842 }
2843 1 => {
2844 let mut var_address =
2845 <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
2846 return crate::bindings::InputType::LiquidAddress {
2847 address: var_address,
2848 };
2849 }
2850 2 => {
2851 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
2852 return crate::bindings::InputType::Bolt11 {
2853 invoice: var_invoice,
2854 };
2855 }
2856 3 => {
2857 let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
2858 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2859 return crate::bindings::InputType::Bolt12Offer {
2860 offer: var_offer,
2861 bip353_address: var_bip353Address,
2862 };
2863 }
2864 4 => {
2865 let mut var_nodeId = <String>::sse_decode(deserializer);
2866 return crate::bindings::InputType::NodeId {
2867 node_id: var_nodeId,
2868 };
2869 }
2870 5 => {
2871 let mut var_url = <String>::sse_decode(deserializer);
2872 return crate::bindings::InputType::Url { url: var_url };
2873 }
2874 6 => {
2875 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
2876 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2877 return crate::bindings::InputType::LnUrlPay {
2878 data: var_data,
2879 bip353_address: var_bip353Address,
2880 };
2881 }
2882 7 => {
2883 let mut var_data =
2884 <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
2885 return crate::bindings::InputType::LnUrlWithdraw { data: var_data };
2886 }
2887 8 => {
2888 let mut var_data =
2889 <crate::bindings::LnUrlAuthRequestData>::sse_decode(deserializer);
2890 return crate::bindings::InputType::LnUrlAuth { data: var_data };
2891 }
2892 9 => {
2893 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
2894 return crate::bindings::InputType::LnUrlError { data: var_data };
2895 }
2896 _ => {
2897 unimplemented!("");
2898 }
2899 }
2900 }
2901}
2902
2903impl SseDecode for crate::model::LightningPaymentLimitsResponse {
2904 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2906 let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
2907 let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
2908 return crate::model::LightningPaymentLimitsResponse {
2909 send: var_send,
2910 receive: var_receive,
2911 };
2912 }
2913}
2914
2915impl SseDecode for crate::model::Limits {
2916 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2918 let mut var_minSat = <u64>::sse_decode(deserializer);
2919 let mut var_maxSat = <u64>::sse_decode(deserializer);
2920 let mut var_maxZeroConfSat = <u64>::sse_decode(deserializer);
2921 return crate::model::Limits {
2922 min_sat: var_minSat,
2923 max_sat: var_maxSat,
2924 max_zero_conf_sat: var_maxZeroConfSat,
2925 };
2926 }
2927}
2928
2929impl SseDecode for crate::bindings::LiquidAddressData {
2930 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2932 let mut var_address = <String>::sse_decode(deserializer);
2933 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2934 let mut var_assetId = <Option<String>>::sse_decode(deserializer);
2935 let mut var_amount = <Option<f64>>::sse_decode(deserializer);
2936 let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2937 let mut var_label = <Option<String>>::sse_decode(deserializer);
2938 let mut var_message = <Option<String>>::sse_decode(deserializer);
2939 return crate::bindings::LiquidAddressData {
2940 address: var_address,
2941 network: var_network,
2942 asset_id: var_assetId,
2943 amount: var_amount,
2944 amount_sat: var_amountSat,
2945 label: var_label,
2946 message: var_message,
2947 };
2948 }
2949}
2950
2951impl SseDecode for crate::model::LiquidNetwork {
2952 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2954 let mut inner = <i32>::sse_decode(deserializer);
2955 return match inner {
2956 0 => crate::model::LiquidNetwork::Mainnet,
2957 1 => crate::model::LiquidNetwork::Testnet,
2958 2 => crate::model::LiquidNetwork::Regtest,
2959 _ => unreachable!("Invalid variant for LiquidNetwork: {}", inner),
2960 };
2961 }
2962}
2963
2964impl SseDecode for Vec<String> {
2965 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2967 let mut len_ = <i32>::sse_decode(deserializer);
2968 let mut ans_ = vec![];
2969 for idx_ in 0..len_ {
2970 ans_.push(<String>::sse_decode(deserializer));
2971 }
2972 return ans_;
2973 }
2974}
2975
2976impl SseDecode for Vec<crate::model::AssetBalance> {
2977 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2979 let mut len_ = <i32>::sse_decode(deserializer);
2980 let mut ans_ = vec![];
2981 for idx_ in 0..len_ {
2982 ans_.push(<crate::model::AssetBalance>::sse_decode(deserializer));
2983 }
2984 return ans_;
2985 }
2986}
2987
2988impl SseDecode for Vec<crate::model::AssetMetadata> {
2989 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2991 let mut len_ = <i32>::sse_decode(deserializer);
2992 let mut ans_ = vec![];
2993 for idx_ in 0..len_ {
2994 ans_.push(<crate::model::AssetMetadata>::sse_decode(deserializer));
2995 }
2996 return ans_;
2997 }
2998}
2999
3000impl SseDecode for Vec<crate::bindings::ExternalInputParser> {
3001 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3003 let mut len_ = <i32>::sse_decode(deserializer);
3004 let mut ans_ = vec![];
3005 for idx_ in 0..len_ {
3006 ans_.push(<crate::bindings::ExternalInputParser>::sse_decode(
3007 deserializer,
3008 ));
3009 }
3010 return ans_;
3011 }
3012}
3013
3014impl SseDecode for Vec<crate::bindings::FiatCurrency> {
3015 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3017 let mut len_ = <i32>::sse_decode(deserializer);
3018 let mut ans_ = vec![];
3019 for idx_ in 0..len_ {
3020 ans_.push(<crate::bindings::FiatCurrency>::sse_decode(deserializer));
3021 }
3022 return ans_;
3023 }
3024}
3025
3026impl SseDecode for Vec<crate::bindings::LnOfferBlindedPath> {
3027 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3029 let mut len_ = <i32>::sse_decode(deserializer);
3030 let mut ans_ = vec![];
3031 for idx_ in 0..len_ {
3032 ans_.push(<crate::bindings::LnOfferBlindedPath>::sse_decode(
3033 deserializer,
3034 ));
3035 }
3036 return ans_;
3037 }
3038}
3039
3040impl SseDecode for Vec<crate::bindings::LocaleOverrides> {
3041 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3043 let mut len_ = <i32>::sse_decode(deserializer);
3044 let mut ans_ = vec![];
3045 for idx_ in 0..len_ {
3046 ans_.push(<crate::bindings::LocaleOverrides>::sse_decode(deserializer));
3047 }
3048 return ans_;
3049 }
3050}
3051
3052impl SseDecode for Vec<crate::bindings::LocalizedName> {
3053 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3055 let mut len_ = <i32>::sse_decode(deserializer);
3056 let mut ans_ = vec![];
3057 for idx_ in 0..len_ {
3058 ans_.push(<crate::bindings::LocalizedName>::sse_decode(deserializer));
3059 }
3060 return ans_;
3061 }
3062}
3063
3064impl SseDecode for Vec<crate::model::Payment> {
3065 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3067 let mut len_ = <i32>::sse_decode(deserializer);
3068 let mut ans_ = vec![];
3069 for idx_ in 0..len_ {
3070 ans_.push(<crate::model::Payment>::sse_decode(deserializer));
3071 }
3072 return ans_;
3073 }
3074}
3075
3076impl SseDecode for crate::model::ListPaymentDetails {
3077 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3079 let mut tag_ = <i32>::sse_decode(deserializer);
3080 match tag_ {
3081 0 => {
3082 let mut var_assetId = <Option<String>>::sse_decode(deserializer);
3083 let mut var_destination = <Option<String>>::sse_decode(deserializer);
3084 return crate::model::ListPaymentDetails::Liquid {
3085 asset_id: var_assetId,
3086 destination: var_destination,
3087 };
3088 }
3089 1 => {
3090 let mut var_address = <Option<String>>::sse_decode(deserializer);
3091 return crate::model::ListPaymentDetails::Bitcoin {
3092 address: var_address,
3093 };
3094 }
3095 _ => {
3096 unimplemented!("");
3097 }
3098 }
3099 }
3100}
3101
3102impl SseDecode for Vec<crate::model::PaymentState> {
3103 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3105 let mut len_ = <i32>::sse_decode(deserializer);
3106 let mut ans_ = vec![];
3107 for idx_ in 0..len_ {
3108 ans_.push(<crate::model::PaymentState>::sse_decode(deserializer));
3109 }
3110 return ans_;
3111 }
3112}
3113
3114impl SseDecode for Vec<crate::model::PaymentType> {
3115 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3117 let mut len_ = <i32>::sse_decode(deserializer);
3118 let mut ans_ = vec![];
3119 for idx_ in 0..len_ {
3120 ans_.push(<crate::model::PaymentType>::sse_decode(deserializer));
3121 }
3122 return ans_;
3123 }
3124}
3125
3126impl SseDecode for crate::model::ListPaymentsRequest {
3127 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3129 let mut var_filters = <Option<Vec<crate::model::PaymentType>>>::sse_decode(deserializer);
3130 let mut var_states = <Option<Vec<crate::model::PaymentState>>>::sse_decode(deserializer);
3131 let mut var_fromTimestamp = <Option<i64>>::sse_decode(deserializer);
3132 let mut var_toTimestamp = <Option<i64>>::sse_decode(deserializer);
3133 let mut var_offset = <Option<u32>>::sse_decode(deserializer);
3134 let mut var_limit = <Option<u32>>::sse_decode(deserializer);
3135 let mut var_details = <Option<crate::model::ListPaymentDetails>>::sse_decode(deserializer);
3136 let mut var_sortAscending = <Option<bool>>::sse_decode(deserializer);
3137 return crate::model::ListPaymentsRequest {
3138 filters: var_filters,
3139 states: var_states,
3140 from_timestamp: var_fromTimestamp,
3141 to_timestamp: var_toTimestamp,
3142 offset: var_offset,
3143 limit: var_limit,
3144 details: var_details,
3145 sort_ascending: var_sortAscending,
3146 };
3147 }
3148}
3149
3150impl SseDecode for Vec<u8> {
3151 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3153 let mut len_ = <i32>::sse_decode(deserializer);
3154 let mut ans_ = vec![];
3155 for idx_ in 0..len_ {
3156 ans_.push(<u8>::sse_decode(deserializer));
3157 }
3158 return ans_;
3159 }
3160}
3161
3162impl SseDecode for Vec<crate::bindings::Rate> {
3163 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3165 let mut len_ = <i32>::sse_decode(deserializer);
3166 let mut ans_ = vec![];
3167 for idx_ in 0..len_ {
3168 ans_.push(<crate::bindings::Rate>::sse_decode(deserializer));
3169 }
3170 return ans_;
3171 }
3172}
3173
3174impl SseDecode for Vec<crate::model::RefundableSwap> {
3175 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3177 let mut len_ = <i32>::sse_decode(deserializer);
3178 let mut ans_ = vec![];
3179 for idx_ in 0..len_ {
3180 ans_.push(<crate::model::RefundableSwap>::sse_decode(deserializer));
3181 }
3182 return ans_;
3183 }
3184}
3185
3186impl SseDecode for Vec<crate::bindings::RouteHint> {
3187 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3189 let mut len_ = <i32>::sse_decode(deserializer);
3190 let mut ans_ = vec![];
3191 for idx_ in 0..len_ {
3192 ans_.push(<crate::bindings::RouteHint>::sse_decode(deserializer));
3193 }
3194 return ans_;
3195 }
3196}
3197
3198impl SseDecode for Vec<crate::bindings::RouteHintHop> {
3199 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3201 let mut len_ = <i32>::sse_decode(deserializer);
3202 let mut ans_ = vec![];
3203 for idx_ in 0..len_ {
3204 ans_.push(<crate::bindings::RouteHintHop>::sse_decode(deserializer));
3205 }
3206 return ans_;
3207 }
3208}
3209
3210impl SseDecode for crate::bindings::LNInvoice {
3211 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3213 let mut var_bolt11 = <String>::sse_decode(deserializer);
3214 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
3215 let mut var_payeePubkey = <String>::sse_decode(deserializer);
3216 let mut var_paymentHash = <String>::sse_decode(deserializer);
3217 let mut var_description = <Option<String>>::sse_decode(deserializer);
3218 let mut var_descriptionHash = <Option<String>>::sse_decode(deserializer);
3219 let mut var_amountMsat = <Option<u64>>::sse_decode(deserializer);
3220 let mut var_timestamp = <u64>::sse_decode(deserializer);
3221 let mut var_expiry = <u64>::sse_decode(deserializer);
3222 let mut var_routingHints = <Vec<crate::bindings::RouteHint>>::sse_decode(deserializer);
3223 let mut var_paymentSecret = <Vec<u8>>::sse_decode(deserializer);
3224 let mut var_minFinalCltvExpiryDelta = <u64>::sse_decode(deserializer);
3225 return crate::bindings::LNInvoice {
3226 bolt11: var_bolt11,
3227 network: var_network,
3228 payee_pubkey: var_payeePubkey,
3229 payment_hash: var_paymentHash,
3230 description: var_description,
3231 description_hash: var_descriptionHash,
3232 amount_msat: var_amountMsat,
3233 timestamp: var_timestamp,
3234 expiry: var_expiry,
3235 routing_hints: var_routingHints,
3236 payment_secret: var_paymentSecret,
3237 min_final_cltv_expiry_delta: var_minFinalCltvExpiryDelta,
3238 };
3239 }
3240}
3241
3242impl SseDecode for crate::bindings::LNOffer {
3243 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3245 let mut var_offer = <String>::sse_decode(deserializer);
3246 let mut var_chains = <Vec<String>>::sse_decode(deserializer);
3247 let mut var_minAmount = <Option<crate::bindings::Amount>>::sse_decode(deserializer);
3248 let mut var_description = <Option<String>>::sse_decode(deserializer);
3249 let mut var_absoluteExpiry = <Option<u64>>::sse_decode(deserializer);
3250 let mut var_issuer = <Option<String>>::sse_decode(deserializer);
3251 let mut var_signingPubkey = <Option<String>>::sse_decode(deserializer);
3252 let mut var_paths = <Vec<crate::bindings::LnOfferBlindedPath>>::sse_decode(deserializer);
3253 return crate::bindings::LNOffer {
3254 offer: var_offer,
3255 chains: var_chains,
3256 min_amount: var_minAmount,
3257 description: var_description,
3258 absolute_expiry: var_absoluteExpiry,
3259 issuer: var_issuer,
3260 signing_pubkey: var_signingPubkey,
3261 paths: var_paths,
3262 };
3263 }
3264}
3265
3266impl SseDecode for crate::bindings::LnOfferBlindedPath {
3267 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3269 let mut var_blindedHops = <Vec<String>>::sse_decode(deserializer);
3270 return crate::bindings::LnOfferBlindedPath {
3271 blinded_hops: var_blindedHops,
3272 };
3273 }
3274}
3275
3276impl SseDecode for crate::bindings::duplicates::LnUrlAuthError {
3277 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3279 let mut tag_ = <i32>::sse_decode(deserializer);
3280 match tag_ {
3281 0 => {
3282 let mut var_err = <String>::sse_decode(deserializer);
3283 return crate::bindings::duplicates::LnUrlAuthError::Generic { err: var_err };
3284 }
3285 1 => {
3286 let mut var_err = <String>::sse_decode(deserializer);
3287 return crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err: var_err };
3288 }
3289 2 => {
3290 let mut var_err = <String>::sse_decode(deserializer);
3291 return crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
3292 err: var_err,
3293 };
3294 }
3295 _ => {
3296 unimplemented!("");
3297 }
3298 }
3299 }
3300}
3301
3302impl SseDecode for crate::bindings::LnUrlAuthRequestData {
3303 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3305 let mut var_k1 = <String>::sse_decode(deserializer);
3306 let mut var_action = <Option<String>>::sse_decode(deserializer);
3307 let mut var_domain = <String>::sse_decode(deserializer);
3308 let mut var_url = <String>::sse_decode(deserializer);
3309 return crate::bindings::LnUrlAuthRequestData {
3310 k1: var_k1,
3311 action: var_action,
3312 domain: var_domain,
3313 url: var_url,
3314 };
3315 }
3316}
3317
3318impl SseDecode for crate::bindings::duplicates::LnUrlCallbackStatus {
3319 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3321 let mut tag_ = <i32>::sse_decode(deserializer);
3322 match tag_ {
3323 0 => {
3324 return crate::bindings::duplicates::LnUrlCallbackStatus::Ok;
3325 }
3326 1 => {
3327 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3328 return crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
3329 data: var_data,
3330 };
3331 }
3332 _ => {
3333 unimplemented!("");
3334 }
3335 }
3336 }
3337}
3338
3339impl SseDecode for crate::bindings::LnUrlErrorData {
3340 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3342 let mut var_reason = <String>::sse_decode(deserializer);
3343 return crate::bindings::LnUrlErrorData { reason: var_reason };
3344 }
3345}
3346
3347impl SseDecode for crate::model::LnUrlInfo {
3348 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3350 let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3351 let mut var_lnurlPayComment = <Option<String>>::sse_decode(deserializer);
3352 let mut var_lnurlPayDomain = <Option<String>>::sse_decode(deserializer);
3353 let mut var_lnurlPayMetadata = <Option<String>>::sse_decode(deserializer);
3354 let mut var_lnurlPaySuccessAction =
3355 <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3356 let mut var_lnurlPayUnprocessedSuccessAction =
3357 <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
3358 let mut var_lnurlWithdrawEndpoint = <Option<String>>::sse_decode(deserializer);
3359 return crate::model::LnUrlInfo {
3360 ln_address: var_lnAddress,
3361 lnurl_pay_comment: var_lnurlPayComment,
3362 lnurl_pay_domain: var_lnurlPayDomain,
3363 lnurl_pay_metadata: var_lnurlPayMetadata,
3364 lnurl_pay_success_action: var_lnurlPaySuccessAction,
3365 lnurl_pay_unprocessed_success_action: var_lnurlPayUnprocessedSuccessAction,
3366 lnurl_withdraw_endpoint: var_lnurlWithdrawEndpoint,
3367 };
3368 }
3369}
3370
3371impl SseDecode for crate::bindings::duplicates::LnUrlPayError {
3372 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3374 let mut tag_ = <i32>::sse_decode(deserializer);
3375 match tag_ {
3376 0 => {
3377 return crate::bindings::duplicates::LnUrlPayError::AlreadyPaid;
3378 }
3379 1 => {
3380 let mut var_err = <String>::sse_decode(deserializer);
3381 return crate::bindings::duplicates::LnUrlPayError::Generic { err: var_err };
3382 }
3383 2 => {
3384 let mut var_err = <String>::sse_decode(deserializer);
3385 return crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
3386 err: var_err,
3387 };
3388 }
3389 3 => {
3390 let mut var_err = <String>::sse_decode(deserializer);
3391 return crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err: var_err };
3392 }
3393 4 => {
3394 let mut var_err = <String>::sse_decode(deserializer);
3395 return crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err: var_err };
3396 }
3397 5 => {
3398 let mut var_err = <String>::sse_decode(deserializer);
3399 return crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err: var_err };
3400 }
3401 6 => {
3402 let mut var_err = <String>::sse_decode(deserializer);
3403 return crate::bindings::duplicates::LnUrlPayError::InvalidUri { err: var_err };
3404 }
3405 7 => {
3406 let mut var_err = <String>::sse_decode(deserializer);
3407 return crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err: var_err };
3408 }
3409 8 => {
3410 let mut var_err = <String>::sse_decode(deserializer);
3411 return crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err: var_err };
3412 }
3413 9 => {
3414 let mut var_err = <String>::sse_decode(deserializer);
3415 return crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err: var_err };
3416 }
3417 10 => {
3418 let mut var_err = <String>::sse_decode(deserializer);
3419 return crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err: var_err };
3420 }
3421 11 => {
3422 let mut var_err = <String>::sse_decode(deserializer);
3423 return crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
3424 err: var_err,
3425 };
3426 }
3427 12 => {
3428 let mut var_err = <String>::sse_decode(deserializer);
3429 return crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
3430 err: var_err,
3431 };
3432 }
3433 _ => {
3434 unimplemented!("");
3435 }
3436 }
3437 }
3438}
3439
3440impl SseDecode for crate::bindings::LnUrlPayErrorData {
3441 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3443 let mut var_paymentHash = <String>::sse_decode(deserializer);
3444 let mut var_reason = <String>::sse_decode(deserializer);
3445 return crate::bindings::LnUrlPayErrorData {
3446 payment_hash: var_paymentHash,
3447 reason: var_reason,
3448 };
3449 }
3450}
3451
3452impl SseDecode for crate::model::LnUrlPayRequest {
3453 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3455 let mut var_prepareResponse =
3456 <crate::model::PrepareLnUrlPayResponse>::sse_decode(deserializer);
3457 return crate::model::LnUrlPayRequest {
3458 prepare_response: var_prepareResponse,
3459 };
3460 }
3461}
3462
3463impl SseDecode for crate::bindings::LnUrlPayRequestData {
3464 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3466 let mut var_callback = <String>::sse_decode(deserializer);
3467 let mut var_minSendable = <u64>::sse_decode(deserializer);
3468 let mut var_maxSendable = <u64>::sse_decode(deserializer);
3469 let mut var_metadataStr = <String>::sse_decode(deserializer);
3470 let mut var_commentAllowed = <u16>::sse_decode(deserializer);
3471 let mut var_domain = <String>::sse_decode(deserializer);
3472 let mut var_allowsNostr = <bool>::sse_decode(deserializer);
3473 let mut var_nostrPubkey = <Option<String>>::sse_decode(deserializer);
3474 let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3475 return crate::bindings::LnUrlPayRequestData {
3476 callback: var_callback,
3477 min_sendable: var_minSendable,
3478 max_sendable: var_maxSendable,
3479 metadata_str: var_metadataStr,
3480 comment_allowed: var_commentAllowed,
3481 domain: var_domain,
3482 allows_nostr: var_allowsNostr,
3483 nostr_pubkey: var_nostrPubkey,
3484 ln_address: var_lnAddress,
3485 };
3486 }
3487}
3488
3489impl SseDecode for crate::model::LnUrlPayResult {
3490 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3492 let mut tag_ = <i32>::sse_decode(deserializer);
3493 match tag_ {
3494 0 => {
3495 let mut var_data = <crate::model::LnUrlPaySuccessData>::sse_decode(deserializer);
3496 return crate::model::LnUrlPayResult::EndpointSuccess { data: var_data };
3497 }
3498 1 => {
3499 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3500 return crate::model::LnUrlPayResult::EndpointError { data: var_data };
3501 }
3502 2 => {
3503 let mut var_data = <crate::bindings::LnUrlPayErrorData>::sse_decode(deserializer);
3504 return crate::model::LnUrlPayResult::PayError { data: var_data };
3505 }
3506 _ => {
3507 unimplemented!("");
3508 }
3509 }
3510 }
3511}
3512
3513impl SseDecode for crate::model::LnUrlPaySuccessData {
3514 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3516 let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
3517 let mut var_successAction =
3518 <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3519 return crate::model::LnUrlPaySuccessData {
3520 payment: var_payment,
3521 success_action: var_successAction,
3522 };
3523 }
3524}
3525
3526impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawError {
3527 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3529 let mut tag_ = <i32>::sse_decode(deserializer);
3530 match tag_ {
3531 0 => {
3532 let mut var_err = <String>::sse_decode(deserializer);
3533 return crate::bindings::duplicates::LnUrlWithdrawError::Generic { err: var_err };
3534 }
3535 1 => {
3536 let mut var_err = <String>::sse_decode(deserializer);
3537 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
3538 err: var_err,
3539 };
3540 }
3541 2 => {
3542 let mut var_err = <String>::sse_decode(deserializer);
3543 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
3544 err: var_err,
3545 };
3546 }
3547 3 => {
3548 let mut var_err = <String>::sse_decode(deserializer);
3549 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
3550 err: var_err,
3551 };
3552 }
3553 4 => {
3554 let mut var_err = <String>::sse_decode(deserializer);
3555 return crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
3556 err: var_err,
3557 };
3558 }
3559 5 => {
3560 let mut var_err = <String>::sse_decode(deserializer);
3561 return crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
3562 err: var_err,
3563 };
3564 }
3565 _ => {
3566 unimplemented!("");
3567 }
3568 }
3569 }
3570}
3571
3572impl SseDecode for crate::bindings::LnUrlWithdrawRequest {
3573 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3575 let mut var_data = <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
3576 let mut var_amountMsat = <u64>::sse_decode(deserializer);
3577 let mut var_description = <Option<String>>::sse_decode(deserializer);
3578 return crate::bindings::LnUrlWithdrawRequest {
3579 data: var_data,
3580 amount_msat: var_amountMsat,
3581 description: var_description,
3582 };
3583 }
3584}
3585
3586impl SseDecode for crate::bindings::LnUrlWithdrawRequestData {
3587 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3589 let mut var_callback = <String>::sse_decode(deserializer);
3590 let mut var_k1 = <String>::sse_decode(deserializer);
3591 let mut var_defaultDescription = <String>::sse_decode(deserializer);
3592 let mut var_minWithdrawable = <u64>::sse_decode(deserializer);
3593 let mut var_maxWithdrawable = <u64>::sse_decode(deserializer);
3594 return crate::bindings::LnUrlWithdrawRequestData {
3595 callback: var_callback,
3596 k1: var_k1,
3597 default_description: var_defaultDescription,
3598 min_withdrawable: var_minWithdrawable,
3599 max_withdrawable: var_maxWithdrawable,
3600 };
3601 }
3602}
3603
3604impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawResult {
3605 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3607 let mut tag_ = <i32>::sse_decode(deserializer);
3608 match tag_ {
3609 0 => {
3610 let mut var_data =
3611 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3612 deserializer,
3613 );
3614 return crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data: var_data };
3615 }
3616 1 => {
3617 let mut var_data =
3618 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3619 deserializer,
3620 );
3621 return crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
3622 data: var_data,
3623 };
3624 }
3625 2 => {
3626 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3627 return crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
3628 data: var_data,
3629 };
3630 }
3631 _ => {
3632 unimplemented!("");
3633 }
3634 }
3635 }
3636}
3637
3638impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3639 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3641 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
3642 return crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3643 invoice: var_invoice,
3644 };
3645 }
3646}
3647
3648impl SseDecode for crate::bindings::LocaleOverrides {
3649 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3651 let mut var_locale = <String>::sse_decode(deserializer);
3652 let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
3653 let mut var_symbol = <crate::bindings::Symbol>::sse_decode(deserializer);
3654 return crate::bindings::LocaleOverrides {
3655 locale: var_locale,
3656 spacing: var_spacing,
3657 symbol: var_symbol,
3658 };
3659 }
3660}
3661
3662impl SseDecode for crate::bindings::LocalizedName {
3663 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3665 let mut var_locale = <String>::sse_decode(deserializer);
3666 let mut var_name = <String>::sse_decode(deserializer);
3667 return crate::bindings::LocalizedName {
3668 locale: var_locale,
3669 name: var_name,
3670 };
3671 }
3672}
3673
3674impl SseDecode for crate::model::LogEntry {
3675 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3677 let mut var_line = <String>::sse_decode(deserializer);
3678 let mut var_level = <String>::sse_decode(deserializer);
3679 return crate::model::LogEntry {
3680 line: var_line,
3681 level: var_level,
3682 };
3683 }
3684}
3685
3686impl SseDecode for crate::bindings::MessageSuccessActionData {
3687 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3689 let mut var_message = <String>::sse_decode(deserializer);
3690 return crate::bindings::MessageSuccessActionData {
3691 message: var_message,
3692 };
3693 }
3694}
3695
3696impl SseDecode for crate::bindings::Network {
3697 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3699 let mut inner = <i32>::sse_decode(deserializer);
3700 return match inner {
3701 0 => crate::bindings::Network::Bitcoin,
3702 1 => crate::bindings::Network::Testnet,
3703 2 => crate::bindings::Network::Signet,
3704 3 => crate::bindings::Network::Regtest,
3705 _ => unreachable!("Invalid variant for Network: {}", inner),
3706 };
3707 }
3708}
3709
3710impl SseDecode for crate::model::OnchainPaymentLimitsResponse {
3711 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3713 let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
3714 let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
3715 return crate::model::OnchainPaymentLimitsResponse {
3716 send: var_send,
3717 receive: var_receive,
3718 };
3719 }
3720}
3721
3722impl SseDecode for Option<String> {
3723 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3725 if (<bool>::sse_decode(deserializer)) {
3726 return Some(<String>::sse_decode(deserializer));
3727 } else {
3728 return None;
3729 }
3730 }
3731}
3732
3733impl SseDecode for Option<crate::bindings::Amount> {
3734 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3736 if (<bool>::sse_decode(deserializer)) {
3737 return Some(<crate::bindings::Amount>::sse_decode(deserializer));
3738 } else {
3739 return None;
3740 }
3741 }
3742}
3743
3744impl SseDecode for Option<crate::model::AssetInfo> {
3745 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3747 if (<bool>::sse_decode(deserializer)) {
3748 return Some(<crate::model::AssetInfo>::sse_decode(deserializer));
3749 } else {
3750 return None;
3751 }
3752 }
3753}
3754
3755impl SseDecode for Option<bool> {
3756 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3758 if (<bool>::sse_decode(deserializer)) {
3759 return Some(<bool>::sse_decode(deserializer));
3760 } else {
3761 return None;
3762 }
3763 }
3764}
3765
3766impl SseDecode for Option<f64> {
3767 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3769 if (<bool>::sse_decode(deserializer)) {
3770 return Some(<f64>::sse_decode(deserializer));
3771 } else {
3772 return None;
3773 }
3774 }
3775}
3776
3777impl SseDecode for Option<i64> {
3778 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3780 if (<bool>::sse_decode(deserializer)) {
3781 return Some(<i64>::sse_decode(deserializer));
3782 } else {
3783 return None;
3784 }
3785 }
3786}
3787
3788impl SseDecode for Option<crate::model::ListPaymentDetails> {
3789 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3791 if (<bool>::sse_decode(deserializer)) {
3792 return Some(<crate::model::ListPaymentDetails>::sse_decode(deserializer));
3793 } else {
3794 return None;
3795 }
3796 }
3797}
3798
3799impl SseDecode for Option<crate::model::LnUrlInfo> {
3800 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3802 if (<bool>::sse_decode(deserializer)) {
3803 return Some(<crate::model::LnUrlInfo>::sse_decode(deserializer));
3804 } else {
3805 return None;
3806 }
3807 }
3808}
3809
3810impl SseDecode for Option<crate::model::PayAmount> {
3811 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3813 if (<bool>::sse_decode(deserializer)) {
3814 return Some(<crate::model::PayAmount>::sse_decode(deserializer));
3815 } else {
3816 return None;
3817 }
3818 }
3819}
3820
3821impl SseDecode for Option<crate::model::Payment> {
3822 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3824 if (<bool>::sse_decode(deserializer)) {
3825 return Some(<crate::model::Payment>::sse_decode(deserializer));
3826 } else {
3827 return None;
3828 }
3829 }
3830}
3831
3832impl SseDecode for Option<crate::model::ReceiveAmount> {
3833 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3835 if (<bool>::sse_decode(deserializer)) {
3836 return Some(<crate::model::ReceiveAmount>::sse_decode(deserializer));
3837 } else {
3838 return None;
3839 }
3840 }
3841}
3842
3843impl SseDecode for Option<crate::bindings::SuccessAction> {
3844 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3846 if (<bool>::sse_decode(deserializer)) {
3847 return Some(<crate::bindings::SuccessAction>::sse_decode(deserializer));
3848 } else {
3849 return None;
3850 }
3851 }
3852}
3853
3854impl SseDecode for Option<crate::bindings::SuccessActionProcessed> {
3855 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3857 if (<bool>::sse_decode(deserializer)) {
3858 return Some(<crate::bindings::SuccessActionProcessed>::sse_decode(
3859 deserializer,
3860 ));
3861 } else {
3862 return None;
3863 }
3864 }
3865}
3866
3867impl SseDecode for Option<crate::bindings::Symbol> {
3868 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3870 if (<bool>::sse_decode(deserializer)) {
3871 return Some(<crate::bindings::Symbol>::sse_decode(deserializer));
3872 } else {
3873 return None;
3874 }
3875 }
3876}
3877
3878impl SseDecode for Option<u32> {
3879 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3881 if (<bool>::sse_decode(deserializer)) {
3882 return Some(<u32>::sse_decode(deserializer));
3883 } else {
3884 return None;
3885 }
3886 }
3887}
3888
3889impl SseDecode for Option<u64> {
3890 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3892 if (<bool>::sse_decode(deserializer)) {
3893 return Some(<u64>::sse_decode(deserializer));
3894 } else {
3895 return None;
3896 }
3897 }
3898}
3899
3900impl SseDecode for Option<Vec<crate::model::AssetMetadata>> {
3901 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3903 if (<bool>::sse_decode(deserializer)) {
3904 return Some(<Vec<crate::model::AssetMetadata>>::sse_decode(deserializer));
3905 } else {
3906 return None;
3907 }
3908 }
3909}
3910
3911impl SseDecode for Option<Vec<crate::bindings::ExternalInputParser>> {
3912 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3914 if (<bool>::sse_decode(deserializer)) {
3915 return Some(<Vec<crate::bindings::ExternalInputParser>>::sse_decode(
3916 deserializer,
3917 ));
3918 } else {
3919 return None;
3920 }
3921 }
3922}
3923
3924impl SseDecode for Option<Vec<crate::model::PaymentState>> {
3925 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3927 if (<bool>::sse_decode(deserializer)) {
3928 return Some(<Vec<crate::model::PaymentState>>::sse_decode(deserializer));
3929 } else {
3930 return None;
3931 }
3932 }
3933}
3934
3935impl SseDecode for Option<Vec<crate::model::PaymentType>> {
3936 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3938 if (<bool>::sse_decode(deserializer)) {
3939 return Some(<Vec<crate::model::PaymentType>>::sse_decode(deserializer));
3940 } else {
3941 return None;
3942 }
3943 }
3944}
3945
3946impl SseDecode for Option<Vec<u8>> {
3947 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3949 if (<bool>::sse_decode(deserializer)) {
3950 return Some(<Vec<u8>>::sse_decode(deserializer));
3951 } else {
3952 return None;
3953 }
3954 }
3955}
3956
3957impl SseDecode for crate::model::PayAmount {
3958 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3960 let mut tag_ = <i32>::sse_decode(deserializer);
3961 match tag_ {
3962 0 => {
3963 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
3964 return crate::model::PayAmount::Bitcoin {
3965 receiver_amount_sat: var_receiverAmountSat,
3966 };
3967 }
3968 1 => {
3969 let mut var_assetId = <String>::sse_decode(deserializer);
3970 let mut var_receiverAmount = <f64>::sse_decode(deserializer);
3971 let mut var_estimateAssetFees = <Option<bool>>::sse_decode(deserializer);
3972 let mut var_payWithBitcoin = <Option<bool>>::sse_decode(deserializer);
3973 return crate::model::PayAmount::Asset {
3974 asset_id: var_assetId,
3975 receiver_amount: var_receiverAmount,
3976 estimate_asset_fees: var_estimateAssetFees,
3977 pay_with_bitcoin: var_payWithBitcoin,
3978 };
3979 }
3980 2 => {
3981 return crate::model::PayAmount::Drain;
3982 }
3983 _ => {
3984 unimplemented!("");
3985 }
3986 }
3987 }
3988}
3989
3990impl SseDecode for crate::model::PayOnchainRequest {
3991 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3993 let mut var_address = <String>::sse_decode(deserializer);
3994 let mut var_prepareResponse =
3995 <crate::model::PreparePayOnchainResponse>::sse_decode(deserializer);
3996 return crate::model::PayOnchainRequest {
3997 address: var_address,
3998 prepare_response: var_prepareResponse,
3999 };
4000 }
4001}
4002
4003impl SseDecode for crate::model::Payment {
4004 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4006 let mut var_destination = <Option<String>>::sse_decode(deserializer);
4007 let mut var_txId = <Option<String>>::sse_decode(deserializer);
4008 let mut var_unblindingData = <Option<String>>::sse_decode(deserializer);
4009 let mut var_timestamp = <u32>::sse_decode(deserializer);
4010 let mut var_amountSat = <u64>::sse_decode(deserializer);
4011 let mut var_feesSat = <u64>::sse_decode(deserializer);
4012 let mut var_swapperFeesSat = <Option<u64>>::sse_decode(deserializer);
4013 let mut var_paymentType = <crate::model::PaymentType>::sse_decode(deserializer);
4014 let mut var_status = <crate::model::PaymentState>::sse_decode(deserializer);
4015 let mut var_details = <crate::model::PaymentDetails>::sse_decode(deserializer);
4016 return crate::model::Payment {
4017 destination: var_destination,
4018 tx_id: var_txId,
4019 unblinding_data: var_unblindingData,
4020 timestamp: var_timestamp,
4021 amount_sat: var_amountSat,
4022 fees_sat: var_feesSat,
4023 swapper_fees_sat: var_swapperFeesSat,
4024 payment_type: var_paymentType,
4025 status: var_status,
4026 details: var_details,
4027 };
4028 }
4029}
4030
4031impl SseDecode for crate::model::PaymentDetails {
4032 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4034 let mut tag_ = <i32>::sse_decode(deserializer);
4035 match tag_ {
4036 0 => {
4037 let mut var_swapId = <String>::sse_decode(deserializer);
4038 let mut var_description = <String>::sse_decode(deserializer);
4039 let mut var_liquidExpirationBlockheight = <u32>::sse_decode(deserializer);
4040 let mut var_preimage = <Option<String>>::sse_decode(deserializer);
4041 let mut var_invoice = <Option<String>>::sse_decode(deserializer);
4042 let mut var_bolt12Offer = <Option<String>>::sse_decode(deserializer);
4043 let mut var_paymentHash = <Option<String>>::sse_decode(deserializer);
4044 let mut var_destinationPubkey = <Option<String>>::sse_decode(deserializer);
4045 let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4046 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4047 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4048 let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4049 let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4050 let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4051 return crate::model::PaymentDetails::Lightning {
4052 swap_id: var_swapId,
4053 description: var_description,
4054 liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4055 preimage: var_preimage,
4056 invoice: var_invoice,
4057 bolt12_offer: var_bolt12Offer,
4058 payment_hash: var_paymentHash,
4059 destination_pubkey: var_destinationPubkey,
4060 lnurl_info: var_lnurlInfo,
4061 bip353_address: var_bip353Address,
4062 payer_note: var_payerNote,
4063 claim_tx_id: var_claimTxId,
4064 refund_tx_id: var_refundTxId,
4065 refund_tx_amount_sat: var_refundTxAmountSat,
4066 };
4067 }
4068 1 => {
4069 let mut var_destination = <String>::sse_decode(deserializer);
4070 let mut var_description = <String>::sse_decode(deserializer);
4071 let mut var_assetId = <String>::sse_decode(deserializer);
4072 let mut var_assetInfo = <Option<crate::model::AssetInfo>>::sse_decode(deserializer);
4073 let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4074 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4075 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4076 return crate::model::PaymentDetails::Liquid {
4077 destination: var_destination,
4078 description: var_description,
4079 asset_id: var_assetId,
4080 asset_info: var_assetInfo,
4081 lnurl_info: var_lnurlInfo,
4082 bip353_address: var_bip353Address,
4083 payer_note: var_payerNote,
4084 };
4085 }
4086 2 => {
4087 let mut var_swapId = <String>::sse_decode(deserializer);
4088 let mut var_bitcoinAddress = <String>::sse_decode(deserializer);
4089 let mut var_description = <String>::sse_decode(deserializer);
4090 let mut var_autoAcceptedFees = <bool>::sse_decode(deserializer);
4091 let mut var_liquidExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4092 let mut var_bitcoinExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4093 let mut var_lockupTxId = <Option<String>>::sse_decode(deserializer);
4094 let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4095 let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4096 let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4097 return crate::model::PaymentDetails::Bitcoin {
4098 swap_id: var_swapId,
4099 bitcoin_address: var_bitcoinAddress,
4100 description: var_description,
4101 auto_accepted_fees: var_autoAcceptedFees,
4102 liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4103 bitcoin_expiration_blockheight: var_bitcoinExpirationBlockheight,
4104 lockup_tx_id: var_lockupTxId,
4105 claim_tx_id: var_claimTxId,
4106 refund_tx_id: var_refundTxId,
4107 refund_tx_amount_sat: var_refundTxAmountSat,
4108 };
4109 }
4110 _ => {
4111 unimplemented!("");
4112 }
4113 }
4114 }
4115}
4116
4117impl SseDecode for crate::error::PaymentError {
4118 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4120 let mut tag_ = <i32>::sse_decode(deserializer);
4121 match tag_ {
4122 0 => {
4123 return crate::error::PaymentError::AlreadyClaimed;
4124 }
4125 1 => {
4126 return crate::error::PaymentError::AlreadyPaid;
4127 }
4128 2 => {
4129 return crate::error::PaymentError::PaymentInProgress;
4130 }
4131 3 => {
4132 let mut var_min = <u64>::sse_decode(deserializer);
4133 let mut var_max = <u64>::sse_decode(deserializer);
4134 return crate::error::PaymentError::AmountOutOfRange {
4135 min: var_min,
4136 max: var_max,
4137 };
4138 }
4139 4 => {
4140 let mut var_err = <String>::sse_decode(deserializer);
4141 return crate::error::PaymentError::AmountMissing { err: var_err };
4142 }
4143 5 => {
4144 let mut var_err = <String>::sse_decode(deserializer);
4145 return crate::error::PaymentError::AssetError { err: var_err };
4146 }
4147 6 => {
4148 let mut var_err = <String>::sse_decode(deserializer);
4149 return crate::error::PaymentError::InvalidNetwork { err: var_err };
4150 }
4151 7 => {
4152 let mut var_err = <String>::sse_decode(deserializer);
4153 return crate::error::PaymentError::Generic { err: var_err };
4154 }
4155 8 => {
4156 return crate::error::PaymentError::InvalidOrExpiredFees;
4157 }
4158 9 => {
4159 return crate::error::PaymentError::InsufficientFunds;
4160 }
4161 10 => {
4162 let mut var_err = <String>::sse_decode(deserializer);
4163 return crate::error::PaymentError::InvalidDescription { err: var_err };
4164 }
4165 11 => {
4166 let mut var_err = <String>::sse_decode(deserializer);
4167 return crate::error::PaymentError::InvalidInvoice { err: var_err };
4168 }
4169 12 => {
4170 return crate::error::PaymentError::InvalidPreimage;
4171 }
4172 13 => {
4173 return crate::error::PaymentError::PairsNotFound;
4174 }
4175 14 => {
4176 return crate::error::PaymentError::PaymentTimeout;
4177 }
4178 15 => {
4179 return crate::error::PaymentError::PersistError;
4180 }
4181 16 => {
4182 let mut var_err = <String>::sse_decode(deserializer);
4183 return crate::error::PaymentError::ReceiveError { err: var_err };
4184 }
4185 17 => {
4186 let mut var_err = <String>::sse_decode(deserializer);
4187 let mut var_refundTxId = <String>::sse_decode(deserializer);
4188 return crate::error::PaymentError::Refunded {
4189 err: var_err,
4190 refund_tx_id: var_refundTxId,
4191 };
4192 }
4193 18 => {
4194 return crate::error::PaymentError::SelfTransferNotSupported;
4195 }
4196 19 => {
4197 let mut var_err = <String>::sse_decode(deserializer);
4198 return crate::error::PaymentError::SendError { err: var_err };
4199 }
4200 20 => {
4201 let mut var_err = <String>::sse_decode(deserializer);
4202 return crate::error::PaymentError::SignerError { err: var_err };
4203 }
4204 _ => {
4205 unimplemented!("");
4206 }
4207 }
4208 }
4209}
4210
4211impl SseDecode for crate::model::PaymentMethod {
4212 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4214 let mut inner = <i32>::sse_decode(deserializer);
4215 return match inner {
4216 0 => crate::model::PaymentMethod::Lightning,
4217 1 => crate::model::PaymentMethod::Bolt11Invoice,
4218 2 => crate::model::PaymentMethod::Bolt12Offer,
4219 3 => crate::model::PaymentMethod::BitcoinAddress,
4220 4 => crate::model::PaymentMethod::LiquidAddress,
4221 _ => unreachable!("Invalid variant for PaymentMethod: {}", inner),
4222 };
4223 }
4224}
4225
4226impl SseDecode for crate::model::PaymentState {
4227 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4229 let mut inner = <i32>::sse_decode(deserializer);
4230 return match inner {
4231 0 => crate::model::PaymentState::Created,
4232 1 => crate::model::PaymentState::Pending,
4233 2 => crate::model::PaymentState::Complete,
4234 3 => crate::model::PaymentState::Failed,
4235 4 => crate::model::PaymentState::TimedOut,
4236 5 => crate::model::PaymentState::Refundable,
4237 6 => crate::model::PaymentState::RefundPending,
4238 7 => crate::model::PaymentState::WaitingFeeAcceptance,
4239 _ => unreachable!("Invalid variant for PaymentState: {}", inner),
4240 };
4241 }
4242}
4243
4244impl SseDecode for crate::model::PaymentType {
4245 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4247 let mut inner = <i32>::sse_decode(deserializer);
4248 return match inner {
4249 0 => crate::model::PaymentType::Receive,
4250 1 => crate::model::PaymentType::Send,
4251 _ => unreachable!("Invalid variant for PaymentType: {}", inner),
4252 };
4253 }
4254}
4255
4256impl SseDecode for crate::model::PrepareBuyBitcoinRequest {
4257 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4259 let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4260 let mut var_amountSat = <u64>::sse_decode(deserializer);
4261 return crate::model::PrepareBuyBitcoinRequest {
4262 provider: var_provider,
4263 amount_sat: var_amountSat,
4264 };
4265 }
4266}
4267
4268impl SseDecode for crate::model::PrepareBuyBitcoinResponse {
4269 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4271 let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4272 let mut var_amountSat = <u64>::sse_decode(deserializer);
4273 let mut var_feesSat = <u64>::sse_decode(deserializer);
4274 return crate::model::PrepareBuyBitcoinResponse {
4275 provider: var_provider,
4276 amount_sat: var_amountSat,
4277 fees_sat: var_feesSat,
4278 };
4279 }
4280}
4281
4282impl SseDecode for crate::model::PrepareLnUrlPayRequest {
4283 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4285 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4286 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4287 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4288 let mut var_comment = <Option<String>>::sse_decode(deserializer);
4289 let mut var_validateSuccessActionUrl = <Option<bool>>::sse_decode(deserializer);
4290 return crate::model::PrepareLnUrlPayRequest {
4291 data: var_data,
4292 amount: var_amount,
4293 bip353_address: var_bip353Address,
4294 comment: var_comment,
4295 validate_success_action_url: var_validateSuccessActionUrl,
4296 };
4297 }
4298}
4299
4300impl SseDecode for crate::model::PrepareLnUrlPayResponse {
4301 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4303 let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4304 let mut var_feesSat = <u64>::sse_decode(deserializer);
4305 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4306 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4307 let mut var_comment = <Option<String>>::sse_decode(deserializer);
4308 let mut var_successAction =
4309 <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
4310 return crate::model::PrepareLnUrlPayResponse {
4311 destination: var_destination,
4312 fees_sat: var_feesSat,
4313 data: var_data,
4314 amount: var_amount,
4315 comment: var_comment,
4316 success_action: var_successAction,
4317 };
4318 }
4319}
4320
4321impl SseDecode for crate::model::PreparePayOnchainRequest {
4322 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4324 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4325 let mut var_feeRateSatPerVbyte = <Option<u32>>::sse_decode(deserializer);
4326 return crate::model::PreparePayOnchainRequest {
4327 amount: var_amount,
4328 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4329 };
4330 }
4331}
4332
4333impl SseDecode for crate::model::PreparePayOnchainResponse {
4334 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4336 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4337 let mut var_claimFeesSat = <u64>::sse_decode(deserializer);
4338 let mut var_totalFeesSat = <u64>::sse_decode(deserializer);
4339 return crate::model::PreparePayOnchainResponse {
4340 receiver_amount_sat: var_receiverAmountSat,
4341 claim_fees_sat: var_claimFeesSat,
4342 total_fees_sat: var_totalFeesSat,
4343 };
4344 }
4345}
4346
4347impl SseDecode for crate::model::PrepareReceiveRequest {
4348 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4350 let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4351 let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4352 return crate::model::PrepareReceiveRequest {
4353 payment_method: var_paymentMethod,
4354 amount: var_amount,
4355 };
4356 }
4357}
4358
4359impl SseDecode for crate::model::PrepareReceiveResponse {
4360 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4362 let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4363 let mut var_feesSat = <u64>::sse_decode(deserializer);
4364 let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4365 let mut var_minPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4366 let mut var_maxPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4367 let mut var_swapperFeerate = <Option<f64>>::sse_decode(deserializer);
4368 return crate::model::PrepareReceiveResponse {
4369 payment_method: var_paymentMethod,
4370 fees_sat: var_feesSat,
4371 amount: var_amount,
4372 min_payer_amount_sat: var_minPayerAmountSat,
4373 max_payer_amount_sat: var_maxPayerAmountSat,
4374 swapper_feerate: var_swapperFeerate,
4375 };
4376 }
4377}
4378
4379impl SseDecode for crate::model::PrepareRefundRequest {
4380 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4382 let mut var_swapAddress = <String>::sse_decode(deserializer);
4383 let mut var_refundAddress = <String>::sse_decode(deserializer);
4384 let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4385 return crate::model::PrepareRefundRequest {
4386 swap_address: var_swapAddress,
4387 refund_address: var_refundAddress,
4388 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4389 };
4390 }
4391}
4392
4393impl SseDecode for crate::model::PrepareRefundResponse {
4394 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4396 let mut var_txVsize = <u32>::sse_decode(deserializer);
4397 let mut var_txFeeSat = <u64>::sse_decode(deserializer);
4398 let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4399 return crate::model::PrepareRefundResponse {
4400 tx_vsize: var_txVsize,
4401 tx_fee_sat: var_txFeeSat,
4402 last_refund_tx_id: var_lastRefundTxId,
4403 };
4404 }
4405}
4406
4407impl SseDecode for crate::model::PrepareSendRequest {
4408 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4410 let mut var_destination = <String>::sse_decode(deserializer);
4411 let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4412 return crate::model::PrepareSendRequest {
4413 destination: var_destination,
4414 amount: var_amount,
4415 };
4416 }
4417}
4418
4419impl SseDecode for crate::model::PrepareSendResponse {
4420 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4422 let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4423 let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4424 let mut var_feesSat = <Option<u64>>::sse_decode(deserializer);
4425 let mut var_estimatedAssetFees = <Option<f64>>::sse_decode(deserializer);
4426 return crate::model::PrepareSendResponse {
4427 destination: var_destination,
4428 amount: var_amount,
4429 fees_sat: var_feesSat,
4430 estimated_asset_fees: var_estimatedAssetFees,
4431 };
4432 }
4433}
4434
4435impl SseDecode for crate::bindings::Rate {
4436 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4438 let mut var_coin = <String>::sse_decode(deserializer);
4439 let mut var_value = <f64>::sse_decode(deserializer);
4440 return crate::bindings::Rate {
4441 coin: var_coin,
4442 value: var_value,
4443 };
4444 }
4445}
4446
4447impl SseDecode for crate::model::ReceiveAmount {
4448 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4450 let mut tag_ = <i32>::sse_decode(deserializer);
4451 match tag_ {
4452 0 => {
4453 let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
4454 return crate::model::ReceiveAmount::Bitcoin {
4455 payer_amount_sat: var_payerAmountSat,
4456 };
4457 }
4458 1 => {
4459 let mut var_assetId = <String>::sse_decode(deserializer);
4460 let mut var_payerAmount = <Option<f64>>::sse_decode(deserializer);
4461 return crate::model::ReceiveAmount::Asset {
4462 asset_id: var_assetId,
4463 payer_amount: var_payerAmount,
4464 };
4465 }
4466 _ => {
4467 unimplemented!("");
4468 }
4469 }
4470 }
4471}
4472
4473impl SseDecode for crate::model::ReceivePaymentRequest {
4474 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4476 let mut var_prepareResponse =
4477 <crate::model::PrepareReceiveResponse>::sse_decode(deserializer);
4478 let mut var_description = <Option<String>>::sse_decode(deserializer);
4479 let mut var_useDescriptionHash = <Option<bool>>::sse_decode(deserializer);
4480 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4481 return crate::model::ReceivePaymentRequest {
4482 prepare_response: var_prepareResponse,
4483 description: var_description,
4484 use_description_hash: var_useDescriptionHash,
4485 payer_note: var_payerNote,
4486 };
4487 }
4488}
4489
4490impl SseDecode for crate::model::ReceivePaymentResponse {
4491 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4493 let mut var_destination = <String>::sse_decode(deserializer);
4494 return crate::model::ReceivePaymentResponse {
4495 destination: var_destination,
4496 };
4497 }
4498}
4499
4500impl SseDecode for crate::model::RecommendedFees {
4501 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4503 let mut var_fastestFee = <u64>::sse_decode(deserializer);
4504 let mut var_halfHourFee = <u64>::sse_decode(deserializer);
4505 let mut var_hourFee = <u64>::sse_decode(deserializer);
4506 let mut var_economyFee = <u64>::sse_decode(deserializer);
4507 let mut var_minimumFee = <u64>::sse_decode(deserializer);
4508 return crate::model::RecommendedFees {
4509 fastest_fee: var_fastestFee,
4510 half_hour_fee: var_halfHourFee,
4511 hour_fee: var_hourFee,
4512 economy_fee: var_economyFee,
4513 minimum_fee: var_minimumFee,
4514 };
4515 }
4516}
4517
4518impl SseDecode for crate::model::RefundRequest {
4519 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4521 let mut var_swapAddress = <String>::sse_decode(deserializer);
4522 let mut var_refundAddress = <String>::sse_decode(deserializer);
4523 let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4524 return crate::model::RefundRequest {
4525 swap_address: var_swapAddress,
4526 refund_address: var_refundAddress,
4527 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4528 };
4529 }
4530}
4531
4532impl SseDecode for crate::model::RefundResponse {
4533 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4535 let mut var_refundTxId = <String>::sse_decode(deserializer);
4536 return crate::model::RefundResponse {
4537 refund_tx_id: var_refundTxId,
4538 };
4539 }
4540}
4541
4542impl SseDecode for crate::model::RefundableSwap {
4543 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4545 let mut var_swapAddress = <String>::sse_decode(deserializer);
4546 let mut var_timestamp = <u32>::sse_decode(deserializer);
4547 let mut var_amountSat = <u64>::sse_decode(deserializer);
4548 let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4549 return crate::model::RefundableSwap {
4550 swap_address: var_swapAddress,
4551 timestamp: var_timestamp,
4552 amount_sat: var_amountSat,
4553 last_refund_tx_id: var_lastRefundTxId,
4554 };
4555 }
4556}
4557
4558impl SseDecode for crate::model::RestoreRequest {
4559 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4561 let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
4562 return crate::model::RestoreRequest {
4563 backup_path: var_backupPath,
4564 };
4565 }
4566}
4567
4568impl SseDecode for crate::bindings::RouteHint {
4569 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4571 let mut var_hops = <Vec<crate::bindings::RouteHintHop>>::sse_decode(deserializer);
4572 return crate::bindings::RouteHint { hops: var_hops };
4573 }
4574}
4575
4576impl SseDecode for crate::bindings::RouteHintHop {
4577 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4579 let mut var_srcNodeId = <String>::sse_decode(deserializer);
4580 let mut var_shortChannelId = <String>::sse_decode(deserializer);
4581 let mut var_feesBaseMsat = <u32>::sse_decode(deserializer);
4582 let mut var_feesProportionalMillionths = <u32>::sse_decode(deserializer);
4583 let mut var_cltvExpiryDelta = <u64>::sse_decode(deserializer);
4584 let mut var_htlcMinimumMsat = <Option<u64>>::sse_decode(deserializer);
4585 let mut var_htlcMaximumMsat = <Option<u64>>::sse_decode(deserializer);
4586 return crate::bindings::RouteHintHop {
4587 src_node_id: var_srcNodeId,
4588 short_channel_id: var_shortChannelId,
4589 fees_base_msat: var_feesBaseMsat,
4590 fees_proportional_millionths: var_feesProportionalMillionths,
4591 cltv_expiry_delta: var_cltvExpiryDelta,
4592 htlc_minimum_msat: var_htlcMinimumMsat,
4593 htlc_maximum_msat: var_htlcMaximumMsat,
4594 };
4595 }
4596}
4597
4598impl SseDecode for crate::error::SdkError {
4599 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4601 let mut tag_ = <i32>::sse_decode(deserializer);
4602 match tag_ {
4603 0 => {
4604 return crate::error::SdkError::AlreadyStarted;
4605 }
4606 1 => {
4607 let mut var_err = <String>::sse_decode(deserializer);
4608 return crate::error::SdkError::Generic { err: var_err };
4609 }
4610 2 => {
4611 return crate::error::SdkError::NotStarted;
4612 }
4613 3 => {
4614 let mut var_err = <String>::sse_decode(deserializer);
4615 return crate::error::SdkError::ServiceConnectivity { err: var_err };
4616 }
4617 _ => {
4618 unimplemented!("");
4619 }
4620 }
4621 }
4622}
4623
4624impl SseDecode for crate::model::SdkEvent {
4625 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4627 let mut tag_ = <i32>::sse_decode(deserializer);
4628 match tag_ {
4629 0 => {
4630 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4631 return crate::model::SdkEvent::PaymentFailed {
4632 details: var_details,
4633 };
4634 }
4635 1 => {
4636 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4637 return crate::model::SdkEvent::PaymentPending {
4638 details: var_details,
4639 };
4640 }
4641 2 => {
4642 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4643 return crate::model::SdkEvent::PaymentRefundable {
4644 details: var_details,
4645 };
4646 }
4647 3 => {
4648 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4649 return crate::model::SdkEvent::PaymentRefunded {
4650 details: var_details,
4651 };
4652 }
4653 4 => {
4654 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4655 return crate::model::SdkEvent::PaymentRefundPending {
4656 details: var_details,
4657 };
4658 }
4659 5 => {
4660 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4661 return crate::model::SdkEvent::PaymentSucceeded {
4662 details: var_details,
4663 };
4664 }
4665 6 => {
4666 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4667 return crate::model::SdkEvent::PaymentWaitingConfirmation {
4668 details: var_details,
4669 };
4670 }
4671 7 => {
4672 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4673 return crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
4674 details: var_details,
4675 };
4676 }
4677 8 => {
4678 return crate::model::SdkEvent::Synced;
4679 }
4680 9 => {
4681 let mut var_didPullNewRecords = <bool>::sse_decode(deserializer);
4682 return crate::model::SdkEvent::DataSynced {
4683 did_pull_new_records: var_didPullNewRecords,
4684 };
4685 }
4686 _ => {
4687 unimplemented!("");
4688 }
4689 }
4690 }
4691}
4692
4693impl SseDecode for crate::model::SendDestination {
4694 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4696 let mut tag_ = <i32>::sse_decode(deserializer);
4697 match tag_ {
4698 0 => {
4699 let mut var_addressData =
4700 <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
4701 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4702 return crate::model::SendDestination::LiquidAddress {
4703 address_data: var_addressData,
4704 bip353_address: var_bip353Address,
4705 };
4706 }
4707 1 => {
4708 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
4709 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4710 return crate::model::SendDestination::Bolt11 {
4711 invoice: var_invoice,
4712 bip353_address: var_bip353Address,
4713 };
4714 }
4715 2 => {
4716 let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
4717 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4718 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4719 return crate::model::SendDestination::Bolt12 {
4720 offer: var_offer,
4721 receiver_amount_sat: var_receiverAmountSat,
4722 bip353_address: var_bip353Address,
4723 };
4724 }
4725 _ => {
4726 unimplemented!("");
4727 }
4728 }
4729 }
4730}
4731
4732impl SseDecode for crate::model::SendPaymentRequest {
4733 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4735 let mut var_prepareResponse = <crate::model::PrepareSendResponse>::sse_decode(deserializer);
4736 let mut var_useAssetFees = <Option<bool>>::sse_decode(deserializer);
4737 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4738 return crate::model::SendPaymentRequest {
4739 prepare_response: var_prepareResponse,
4740 use_asset_fees: var_useAssetFees,
4741 payer_note: var_payerNote,
4742 };
4743 }
4744}
4745
4746impl SseDecode for crate::model::SendPaymentResponse {
4747 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4749 let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
4750 return crate::model::SendPaymentResponse {
4751 payment: var_payment,
4752 };
4753 }
4754}
4755
4756impl SseDecode for crate::model::SignMessageRequest {
4757 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4759 let mut var_message = <String>::sse_decode(deserializer);
4760 return crate::model::SignMessageRequest {
4761 message: var_message,
4762 };
4763 }
4764}
4765
4766impl SseDecode for crate::model::SignMessageResponse {
4767 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4769 let mut var_signature = <String>::sse_decode(deserializer);
4770 return crate::model::SignMessageResponse {
4771 signature: var_signature,
4772 };
4773 }
4774}
4775
4776impl SseDecode for crate::bindings::SuccessAction {
4777 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4779 let mut tag_ = <i32>::sse_decode(deserializer);
4780 match tag_ {
4781 0 => {
4782 let mut var_data =
4783 <crate::bindings::AesSuccessActionData>::sse_decode(deserializer);
4784 return crate::bindings::SuccessAction::Aes { data: var_data };
4785 }
4786 1 => {
4787 let mut var_data =
4788 <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4789 return crate::bindings::SuccessAction::Message { data: var_data };
4790 }
4791 2 => {
4792 let mut var_data =
4793 <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4794 return crate::bindings::SuccessAction::Url { data: var_data };
4795 }
4796 _ => {
4797 unimplemented!("");
4798 }
4799 }
4800 }
4801}
4802
4803impl SseDecode for crate::bindings::SuccessActionProcessed {
4804 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4806 let mut tag_ = <i32>::sse_decode(deserializer);
4807 match tag_ {
4808 0 => {
4809 let mut var_result =
4810 <crate::bindings::AesSuccessActionDataResult>::sse_decode(deserializer);
4811 return crate::bindings::SuccessActionProcessed::Aes { result: var_result };
4812 }
4813 1 => {
4814 let mut var_data =
4815 <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4816 return crate::bindings::SuccessActionProcessed::Message { data: var_data };
4817 }
4818 2 => {
4819 let mut var_data =
4820 <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4821 return crate::bindings::SuccessActionProcessed::Url { data: var_data };
4822 }
4823 _ => {
4824 unimplemented!("");
4825 }
4826 }
4827 }
4828}
4829
4830impl SseDecode for crate::bindings::Symbol {
4831 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4833 let mut var_grapheme = <Option<String>>::sse_decode(deserializer);
4834 let mut var_template = <Option<String>>::sse_decode(deserializer);
4835 let mut var_rtl = <Option<bool>>::sse_decode(deserializer);
4836 let mut var_position = <Option<u32>>::sse_decode(deserializer);
4837 return crate::bindings::Symbol {
4838 grapheme: var_grapheme,
4839 template: var_template,
4840 rtl: var_rtl,
4841 position: var_position,
4842 };
4843 }
4844}
4845
4846impl SseDecode for u16 {
4847 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4849 deserializer.cursor.read_u16::<NativeEndian>().unwrap()
4850 }
4851}
4852
4853impl SseDecode for u32 {
4854 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4856 deserializer.cursor.read_u32::<NativeEndian>().unwrap()
4857 }
4858}
4859
4860impl SseDecode for u64 {
4861 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4863 deserializer.cursor.read_u64::<NativeEndian>().unwrap()
4864 }
4865}
4866
4867impl SseDecode for u8 {
4868 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4870 deserializer.cursor.read_u8().unwrap()
4871 }
4872}
4873
4874impl SseDecode for () {
4875 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
4877}
4878
4879impl SseDecode for crate::bindings::UrlSuccessActionData {
4880 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4882 let mut var_description = <String>::sse_decode(deserializer);
4883 let mut var_url = <String>::sse_decode(deserializer);
4884 let mut var_matchesCallbackDomain = <bool>::sse_decode(deserializer);
4885 return crate::bindings::UrlSuccessActionData {
4886 description: var_description,
4887 url: var_url,
4888 matches_callback_domain: var_matchesCallbackDomain,
4889 };
4890 }
4891}
4892
4893impl SseDecode for usize {
4894 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4896 deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
4897 }
4898}
4899
4900impl SseDecode for crate::model::WalletInfo {
4901 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4903 let mut var_balanceSat = <u64>::sse_decode(deserializer);
4904 let mut var_pendingSendSat = <u64>::sse_decode(deserializer);
4905 let mut var_pendingReceiveSat = <u64>::sse_decode(deserializer);
4906 let mut var_fingerprint = <String>::sse_decode(deserializer);
4907 let mut var_pubkey = <String>::sse_decode(deserializer);
4908 let mut var_assetBalances = <Vec<crate::model::AssetBalance>>::sse_decode(deserializer);
4909 return crate::model::WalletInfo {
4910 balance_sat: var_balanceSat,
4911 pending_send_sat: var_pendingSendSat,
4912 pending_receive_sat: var_pendingReceiveSat,
4913 fingerprint: var_fingerprint,
4914 pubkey: var_pubkey,
4915 asset_balances: var_assetBalances,
4916 };
4917 }
4918}
4919
4920fn pde_ffi_dispatcher_primary_impl(
4921 func_id: i32,
4922 port: flutter_rust_bridge::for_generated::MessagePort,
4923 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4924 rust_vec_len: i32,
4925 data_len: i32,
4926) {
4927 match func_id {
4929 _ => unreachable!(),
4930 }
4931}
4932
4933fn pde_ffi_dispatcher_sync_impl(
4934 func_id: i32,
4935 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4936 rust_vec_len: i32,
4937 data_len: i32,
4938) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
4939 match func_id {
4941 _ => unreachable!(),
4942 }
4943}
4944
4945impl flutter_rust_bridge::IntoDart for FrbWrapper<BindingLiquidSdk> {
4949 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4950 flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0)
4951 .into_dart()
4952 }
4953}
4954impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<BindingLiquidSdk> {}
4955
4956impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<BindingLiquidSdk>> for BindingLiquidSdk {
4957 fn into_into_dart(self) -> FrbWrapper<BindingLiquidSdk> {
4958 self.into()
4959 }
4960}
4961
4962impl flutter_rust_bridge::IntoDart for crate::model::AcceptPaymentProposedFeesRequest {
4964 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4965 [self.response.into_into_dart().into_dart()].into_dart()
4966 }
4967}
4968impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4969 for crate::model::AcceptPaymentProposedFeesRequest
4970{
4971}
4972impl flutter_rust_bridge::IntoIntoDart<crate::model::AcceptPaymentProposedFeesRequest>
4973 for crate::model::AcceptPaymentProposedFeesRequest
4974{
4975 fn into_into_dart(self) -> crate::model::AcceptPaymentProposedFeesRequest {
4976 self
4977 }
4978}
4979impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionData> {
4981 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4982 [
4983 self.0.description.into_into_dart().into_dart(),
4984 self.0.ciphertext.into_into_dart().into_dart(),
4985 self.0.iv.into_into_dart().into_dart(),
4986 ]
4987 .into_dart()
4988 }
4989}
4990impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4991 for FrbWrapper<crate::bindings::AesSuccessActionData>
4992{
4993}
4994impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionData>>
4995 for crate::bindings::AesSuccessActionData
4996{
4997 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionData> {
4998 self.into()
4999 }
5000}
5001impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5003 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5004 [
5005 self.0.description.into_into_dart().into_dart(),
5006 self.0.plaintext.into_into_dart().into_dart(),
5007 ]
5008 .into_dart()
5009 }
5010}
5011impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5012 for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>
5013{
5014}
5015impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>>
5016 for crate::bindings::AesSuccessActionDataDecrypted
5017{
5018 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5019 self.into()
5020 }
5021}
5022impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5024 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5025 match self.0 {
5026 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
5027 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
5028 }
5029 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
5030 [1.into_dart(), reason.into_into_dart().into_dart()].into_dart()
5031 }
5032 _ => {
5033 unimplemented!("");
5034 }
5035 }
5036 }
5037}
5038impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5039 for FrbWrapper<crate::bindings::AesSuccessActionDataResult>
5040{
5041}
5042impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataResult>>
5043 for crate::bindings::AesSuccessActionDataResult
5044{
5045 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5046 self.into()
5047 }
5048}
5049impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Amount> {
5051 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5052 match self.0 {
5053 crate::bindings::Amount::Bitcoin { amount_msat } => {
5054 [0.into_dart(), amount_msat.into_into_dart().into_dart()].into_dart()
5055 }
5056 crate::bindings::Amount::Currency {
5057 iso4217_code,
5058 fractional_amount,
5059 } => [
5060 1.into_dart(),
5061 iso4217_code.into_into_dart().into_dart(),
5062 fractional_amount.into_into_dart().into_dart(),
5063 ]
5064 .into_dart(),
5065 _ => {
5066 unimplemented!("");
5067 }
5068 }
5069 }
5070}
5071impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5072 for FrbWrapper<crate::bindings::Amount>
5073{
5074}
5075impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Amount>>
5076 for crate::bindings::Amount
5077{
5078 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Amount> {
5079 self.into()
5080 }
5081}
5082impl flutter_rust_bridge::IntoDart for crate::model::AssetBalance {
5084 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5085 [
5086 self.asset_id.into_into_dart().into_dart(),
5087 self.balance_sat.into_into_dart().into_dart(),
5088 self.name.into_into_dart().into_dart(),
5089 self.ticker.into_into_dart().into_dart(),
5090 self.balance.into_into_dart().into_dart(),
5091 ]
5092 .into_dart()
5093 }
5094}
5095impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetBalance {}
5096impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetBalance> for crate::model::AssetBalance {
5097 fn into_into_dart(self) -> crate::model::AssetBalance {
5098 self
5099 }
5100}
5101impl flutter_rust_bridge::IntoDart for crate::model::AssetInfo {
5103 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5104 [
5105 self.name.into_into_dart().into_dart(),
5106 self.ticker.into_into_dart().into_dart(),
5107 self.amount.into_into_dart().into_dart(),
5108 self.fees.into_into_dart().into_dart(),
5109 ]
5110 .into_dart()
5111 }
5112}
5113impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetInfo {}
5114impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetInfo> for crate::model::AssetInfo {
5115 fn into_into_dart(self) -> crate::model::AssetInfo {
5116 self
5117 }
5118}
5119impl flutter_rust_bridge::IntoDart for crate::model::AssetMetadata {
5121 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5122 [
5123 self.asset_id.into_into_dart().into_dart(),
5124 self.name.into_into_dart().into_dart(),
5125 self.ticker.into_into_dart().into_dart(),
5126 self.precision.into_into_dart().into_dart(),
5127 self.fiat_id.into_into_dart().into_dart(),
5128 ]
5129 .into_dart()
5130 }
5131}
5132impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetMetadata {}
5133impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetMetadata>
5134 for crate::model::AssetMetadata
5135{
5136 fn into_into_dart(self) -> crate::model::AssetMetadata {
5137 self
5138 }
5139}
5140impl flutter_rust_bridge::IntoDart for crate::model::BackupRequest {
5142 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5143 [self.backup_path.into_into_dart().into_dart()].into_dart()
5144 }
5145}
5146impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BackupRequest {}
5147impl flutter_rust_bridge::IntoIntoDart<crate::model::BackupRequest>
5148 for crate::model::BackupRequest
5149{
5150 fn into_into_dart(self) -> crate::model::BackupRequest {
5151 self
5152 }
5153}
5154impl flutter_rust_bridge::IntoDart for crate::bindings::BindingEventListener {
5156 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5157 [self.stream.into_into_dart().into_dart()].into_dart()
5158 }
5159}
5160impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5161 for crate::bindings::BindingEventListener
5162{
5163}
5164impl flutter_rust_bridge::IntoIntoDart<crate::bindings::BindingEventListener>
5165 for crate::bindings::BindingEventListener
5166{
5167 fn into_into_dart(self) -> crate::bindings::BindingEventListener {
5168 self
5169 }
5170}
5171impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::BitcoinAddressData> {
5173 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5174 [
5175 self.0.address.into_into_dart().into_dart(),
5176 self.0.network.into_into_dart().into_dart(),
5177 self.0.amount_sat.into_into_dart().into_dart(),
5178 self.0.label.into_into_dart().into_dart(),
5179 self.0.message.into_into_dart().into_dart(),
5180 ]
5181 .into_dart()
5182 }
5183}
5184impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5185 for FrbWrapper<crate::bindings::BitcoinAddressData>
5186{
5187}
5188impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::BitcoinAddressData>>
5189 for crate::bindings::BitcoinAddressData
5190{
5191 fn into_into_dart(self) -> FrbWrapper<crate::bindings::BitcoinAddressData> {
5192 self.into()
5193 }
5194}
5195impl flutter_rust_bridge::IntoDart for crate::model::BlockchainExplorer {
5197 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5198 match self {
5199 crate::model::BlockchainExplorer::Electrum { url } => {
5200 [0.into_dart(), url.into_into_dart().into_dart()].into_dart()
5201 }
5202 crate::model::BlockchainExplorer::Esplora {
5203 url,
5204 use_waterfalls,
5205 } => [
5206 1.into_dart(),
5207 url.into_into_dart().into_dart(),
5208 use_waterfalls.into_into_dart().into_dart(),
5209 ]
5210 .into_dart(),
5211 _ => {
5212 unimplemented!("");
5213 }
5214 }
5215 }
5216}
5217impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5218 for crate::model::BlockchainExplorer
5219{
5220}
5221impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainExplorer>
5222 for crate::model::BlockchainExplorer
5223{
5224 fn into_into_dart(self) -> crate::model::BlockchainExplorer {
5225 self
5226 }
5227}
5228impl flutter_rust_bridge::IntoDart for crate::model::BlockchainInfo {
5230 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5231 [
5232 self.liquid_tip.into_into_dart().into_dart(),
5233 self.bitcoin_tip.into_into_dart().into_dart(),
5234 ]
5235 .into_dart()
5236 }
5237}
5238impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BlockchainInfo {}
5239impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainInfo>
5240 for crate::model::BlockchainInfo
5241{
5242 fn into_into_dart(self) -> crate::model::BlockchainInfo {
5243 self
5244 }
5245}
5246impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinProvider {
5248 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5249 match self {
5250 Self::Moonpay => 0.into_dart(),
5251 _ => unreachable!(),
5252 }
5253 }
5254}
5255impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5256 for crate::model::BuyBitcoinProvider
5257{
5258}
5259impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinProvider>
5260 for crate::model::BuyBitcoinProvider
5261{
5262 fn into_into_dart(self) -> crate::model::BuyBitcoinProvider {
5263 self
5264 }
5265}
5266impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinRequest {
5268 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5269 [
5270 self.prepare_response.into_into_dart().into_dart(),
5271 self.redirect_url.into_into_dart().into_dart(),
5272 ]
5273 .into_dart()
5274 }
5275}
5276impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5277 for crate::model::BuyBitcoinRequest
5278{
5279}
5280impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinRequest>
5281 for crate::model::BuyBitcoinRequest
5282{
5283 fn into_into_dart(self) -> crate::model::BuyBitcoinRequest {
5284 self
5285 }
5286}
5287impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageRequest {
5289 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5290 [
5291 self.message.into_into_dart().into_dart(),
5292 self.pubkey.into_into_dart().into_dart(),
5293 self.signature.into_into_dart().into_dart(),
5294 ]
5295 .into_dart()
5296 }
5297}
5298impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5299 for crate::model::CheckMessageRequest
5300{
5301}
5302impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageRequest>
5303 for crate::model::CheckMessageRequest
5304{
5305 fn into_into_dart(self) -> crate::model::CheckMessageRequest {
5306 self
5307 }
5308}
5309impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageResponse {
5311 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5312 [self.is_valid.into_into_dart().into_dart()].into_dart()
5313 }
5314}
5315impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5316 for crate::model::CheckMessageResponse
5317{
5318}
5319impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageResponse>
5320 for crate::model::CheckMessageResponse
5321{
5322 fn into_into_dart(self) -> crate::model::CheckMessageResponse {
5323 self
5324 }
5325}
5326impl flutter_rust_bridge::IntoDart for crate::model::Config {
5328 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5329 [
5330 self.liquid_explorer.into_into_dart().into_dart(),
5331 self.bitcoin_explorer.into_into_dart().into_dart(),
5332 self.working_dir.into_into_dart().into_dart(),
5333 self.network.into_into_dart().into_dart(),
5334 self.payment_timeout_sec.into_into_dart().into_dart(),
5335 self.sync_service_url.into_into_dart().into_dart(),
5336 self.zero_conf_max_amount_sat.into_into_dart().into_dart(),
5337 self.breez_api_key.into_into_dart().into_dart(),
5338 self.external_input_parsers.into_into_dart().into_dart(),
5339 self.use_default_external_input_parsers
5340 .into_into_dart()
5341 .into_dart(),
5342 self.onchain_fee_rate_leeway_sat
5343 .into_into_dart()
5344 .into_dart(),
5345 self.asset_metadata.into_into_dart().into_dart(),
5346 self.sideswap_api_key.into_into_dart().into_dart(),
5347 ]
5348 .into_dart()
5349 }
5350}
5351impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Config {}
5352impl flutter_rust_bridge::IntoIntoDart<crate::model::Config> for crate::model::Config {
5353 fn into_into_dart(self) -> crate::model::Config {
5354 self
5355 }
5356}
5357impl flutter_rust_bridge::IntoDart for crate::model::ConnectRequest {
5359 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5360 [
5361 self.config.into_into_dart().into_dart(),
5362 self.mnemonic.into_into_dart().into_dart(),
5363 self.passphrase.into_into_dart().into_dart(),
5364 self.seed.into_into_dart().into_dart(),
5365 ]
5366 .into_dart()
5367 }
5368}
5369impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ConnectRequest {}
5370impl flutter_rust_bridge::IntoIntoDart<crate::model::ConnectRequest>
5371 for crate::model::ConnectRequest
5372{
5373 fn into_into_dart(self) -> crate::model::ConnectRequest {
5374 self
5375 }
5376}
5377impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceRequest {
5379 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5380 [
5381 self.offer.into_into_dart().into_dart(),
5382 self.invoice_request.into_into_dart().into_dart(),
5383 ]
5384 .into_dart()
5385 }
5386}
5387impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5388 for crate::model::CreateBolt12InvoiceRequest
5389{
5390}
5391impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceRequest>
5392 for crate::model::CreateBolt12InvoiceRequest
5393{
5394 fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceRequest {
5395 self
5396 }
5397}
5398impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceResponse {
5400 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5401 [self.invoice.into_into_dart().into_dart()].into_dart()
5402 }
5403}
5404impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5405 for crate::model::CreateBolt12InvoiceResponse
5406{
5407}
5408impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceResponse>
5409 for crate::model::CreateBolt12InvoiceResponse
5410{
5411 fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceResponse {
5412 self
5413 }
5414}
5415impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::CurrencyInfo> {
5417 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5418 [
5419 self.0.name.into_into_dart().into_dart(),
5420 self.0.fraction_size.into_into_dart().into_dart(),
5421 self.0.spacing.into_into_dart().into_dart(),
5422 self.0.symbol.into_into_dart().into_dart(),
5423 self.0.uniq_symbol.into_into_dart().into_dart(),
5424 self.0.localized_name.into_into_dart().into_dart(),
5425 self.0.locale_overrides.into_into_dart().into_dart(),
5426 ]
5427 .into_dart()
5428 }
5429}
5430impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5431 for FrbWrapper<crate::bindings::CurrencyInfo>
5432{
5433}
5434impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::CurrencyInfo>>
5435 for crate::bindings::CurrencyInfo
5436{
5437 fn into_into_dart(self) -> FrbWrapper<crate::bindings::CurrencyInfo> {
5438 self.into()
5439 }
5440}
5441impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::ExternalInputParser> {
5443 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5444 [
5445 self.0.provider_id.into_into_dart().into_dart(),
5446 self.0.input_regex.into_into_dart().into_dart(),
5447 self.0.parser_url.into_into_dart().into_dart(),
5448 ]
5449 .into_dart()
5450 }
5451}
5452impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5453 for FrbWrapper<crate::bindings::ExternalInputParser>
5454{
5455}
5456impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::ExternalInputParser>>
5457 for crate::bindings::ExternalInputParser
5458{
5459 fn into_into_dart(self) -> FrbWrapper<crate::bindings::ExternalInputParser> {
5460 self.into()
5461 }
5462}
5463impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesRequest {
5465 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5466 [self.swap_id.into_into_dart().into_dart()].into_dart()
5467 }
5468}
5469impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5470 for crate::model::FetchPaymentProposedFeesRequest
5471{
5472}
5473impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesRequest>
5474 for crate::model::FetchPaymentProposedFeesRequest
5475{
5476 fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesRequest {
5477 self
5478 }
5479}
5480impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesResponse {
5482 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5483 [
5484 self.swap_id.into_into_dart().into_dart(),
5485 self.fees_sat.into_into_dart().into_dart(),
5486 self.payer_amount_sat.into_into_dart().into_dart(),
5487 self.receiver_amount_sat.into_into_dart().into_dart(),
5488 ]
5489 .into_dart()
5490 }
5491}
5492impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5493 for crate::model::FetchPaymentProposedFeesResponse
5494{
5495}
5496impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesResponse>
5497 for crate::model::FetchPaymentProposedFeesResponse
5498{
5499 fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesResponse {
5500 self
5501 }
5502}
5503impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::FiatCurrency> {
5505 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5506 [
5507 self.0.id.into_into_dart().into_dart(),
5508 self.0.info.into_into_dart().into_dart(),
5509 ]
5510 .into_dart()
5511 }
5512}
5513impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5514 for FrbWrapper<crate::bindings::FiatCurrency>
5515{
5516}
5517impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::FiatCurrency>>
5518 for crate::bindings::FiatCurrency
5519{
5520 fn into_into_dart(self) -> FrbWrapper<crate::bindings::FiatCurrency> {
5521 self.into()
5522 }
5523}
5524impl flutter_rust_bridge::IntoDart for crate::model::GetInfoResponse {
5526 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5527 [
5528 self.wallet_info.into_into_dart().into_dart(),
5529 self.blockchain_info.into_into_dart().into_dart(),
5530 ]
5531 .into_dart()
5532 }
5533}
5534impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::GetInfoResponse {}
5535impl flutter_rust_bridge::IntoIntoDart<crate::model::GetInfoResponse>
5536 for crate::model::GetInfoResponse
5537{
5538 fn into_into_dart(self) -> crate::model::GetInfoResponse {
5539 self
5540 }
5541}
5542impl flutter_rust_bridge::IntoDart for crate::model::GetPaymentRequest {
5544 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5545 match self {
5546 crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
5547 [0.into_dart(), payment_hash.into_into_dart().into_dart()].into_dart()
5548 }
5549 crate::model::GetPaymentRequest::SwapId { swap_id } => {
5550 [1.into_dart(), swap_id.into_into_dart().into_dart()].into_dart()
5551 }
5552 _ => {
5553 unimplemented!("");
5554 }
5555 }
5556 }
5557}
5558impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5559 for crate::model::GetPaymentRequest
5560{
5561}
5562impl flutter_rust_bridge::IntoIntoDart<crate::model::GetPaymentRequest>
5563 for crate::model::GetPaymentRequest
5564{
5565 fn into_into_dart(self) -> crate::model::GetPaymentRequest {
5566 self
5567 }
5568}
5569impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::InputType> {
5571 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5572 match self.0 {
5573 crate::bindings::InputType::BitcoinAddress { address } => {
5574 [0.into_dart(), address.into_into_dart().into_dart()].into_dart()
5575 }
5576 crate::bindings::InputType::LiquidAddress { address } => {
5577 [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5578 }
5579 crate::bindings::InputType::Bolt11 { invoice } => {
5580 [2.into_dart(), invoice.into_into_dart().into_dart()].into_dart()
5581 }
5582 crate::bindings::InputType::Bolt12Offer {
5583 offer,
5584 bip353_address,
5585 } => [
5586 3.into_dart(),
5587 offer.into_into_dart().into_dart(),
5588 bip353_address.into_into_dart().into_dart(),
5589 ]
5590 .into_dart(),
5591 crate::bindings::InputType::NodeId { node_id } => {
5592 [4.into_dart(), node_id.into_into_dart().into_dart()].into_dart()
5593 }
5594 crate::bindings::InputType::Url { url } => {
5595 [5.into_dart(), url.into_into_dart().into_dart()].into_dart()
5596 }
5597 crate::bindings::InputType::LnUrlPay {
5598 data,
5599 bip353_address,
5600 } => [
5601 6.into_dart(),
5602 data.into_into_dart().into_dart(),
5603 bip353_address.into_into_dart().into_dart(),
5604 ]
5605 .into_dart(),
5606 crate::bindings::InputType::LnUrlWithdraw { data } => {
5607 [7.into_dart(), data.into_into_dart().into_dart()].into_dart()
5608 }
5609 crate::bindings::InputType::LnUrlAuth { data } => {
5610 [8.into_dart(), data.into_into_dart().into_dart()].into_dart()
5611 }
5612 crate::bindings::InputType::LnUrlError { data } => {
5613 [9.into_dart(), data.into_into_dart().into_dart()].into_dart()
5614 }
5615 _ => {
5616 unimplemented!("");
5617 }
5618 }
5619 }
5620}
5621impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5622 for FrbWrapper<crate::bindings::InputType>
5623{
5624}
5625impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::InputType>>
5626 for crate::bindings::InputType
5627{
5628 fn into_into_dart(self) -> FrbWrapper<crate::bindings::InputType> {
5629 self.into()
5630 }
5631}
5632impl flutter_rust_bridge::IntoDart for crate::model::LightningPaymentLimitsResponse {
5634 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5635 [
5636 self.send.into_into_dart().into_dart(),
5637 self.receive.into_into_dart().into_dart(),
5638 ]
5639 .into_dart()
5640 }
5641}
5642impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5643 for crate::model::LightningPaymentLimitsResponse
5644{
5645}
5646impl flutter_rust_bridge::IntoIntoDart<crate::model::LightningPaymentLimitsResponse>
5647 for crate::model::LightningPaymentLimitsResponse
5648{
5649 fn into_into_dart(self) -> crate::model::LightningPaymentLimitsResponse {
5650 self
5651 }
5652}
5653impl flutter_rust_bridge::IntoDart for crate::model::Limits {
5655 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5656 [
5657 self.min_sat.into_into_dart().into_dart(),
5658 self.max_sat.into_into_dart().into_dart(),
5659 self.max_zero_conf_sat.into_into_dart().into_dart(),
5660 ]
5661 .into_dart()
5662 }
5663}
5664impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Limits {}
5665impl flutter_rust_bridge::IntoIntoDart<crate::model::Limits> for crate::model::Limits {
5666 fn into_into_dart(self) -> crate::model::Limits {
5667 self
5668 }
5669}
5670impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LiquidAddressData> {
5672 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5673 [
5674 self.0.address.into_into_dart().into_dart(),
5675 self.0.network.into_into_dart().into_dart(),
5676 self.0.asset_id.into_into_dart().into_dart(),
5677 self.0.amount.into_into_dart().into_dart(),
5678 self.0.amount_sat.into_into_dart().into_dart(),
5679 self.0.label.into_into_dart().into_dart(),
5680 self.0.message.into_into_dart().into_dart(),
5681 ]
5682 .into_dart()
5683 }
5684}
5685impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5686 for FrbWrapper<crate::bindings::LiquidAddressData>
5687{
5688}
5689impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LiquidAddressData>>
5690 for crate::bindings::LiquidAddressData
5691{
5692 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LiquidAddressData> {
5693 self.into()
5694 }
5695}
5696impl flutter_rust_bridge::IntoDart for crate::model::LiquidNetwork {
5698 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5699 match self {
5700 Self::Mainnet => 0.into_dart(),
5701 Self::Testnet => 1.into_dart(),
5702 Self::Regtest => 2.into_dart(),
5703 _ => unreachable!(),
5704 }
5705 }
5706}
5707impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LiquidNetwork {}
5708impl flutter_rust_bridge::IntoIntoDart<crate::model::LiquidNetwork>
5709 for crate::model::LiquidNetwork
5710{
5711 fn into_into_dart(self) -> crate::model::LiquidNetwork {
5712 self
5713 }
5714}
5715impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentDetails {
5717 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5718 match self {
5719 crate::model::ListPaymentDetails::Liquid {
5720 asset_id,
5721 destination,
5722 } => [
5723 0.into_dart(),
5724 asset_id.into_into_dart().into_dart(),
5725 destination.into_into_dart().into_dart(),
5726 ]
5727 .into_dart(),
5728 crate::model::ListPaymentDetails::Bitcoin { address } => {
5729 [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5730 }
5731 _ => {
5732 unimplemented!("");
5733 }
5734 }
5735 }
5736}
5737impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5738 for crate::model::ListPaymentDetails
5739{
5740}
5741impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentDetails>
5742 for crate::model::ListPaymentDetails
5743{
5744 fn into_into_dart(self) -> crate::model::ListPaymentDetails {
5745 self
5746 }
5747}
5748impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentsRequest {
5750 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5751 [
5752 self.filters.into_into_dart().into_dart(),
5753 self.states.into_into_dart().into_dart(),
5754 self.from_timestamp.into_into_dart().into_dart(),
5755 self.to_timestamp.into_into_dart().into_dart(),
5756 self.offset.into_into_dart().into_dart(),
5757 self.limit.into_into_dart().into_dart(),
5758 self.details.into_into_dart().into_dart(),
5759 self.sort_ascending.into_into_dart().into_dart(),
5760 ]
5761 .into_dart()
5762 }
5763}
5764impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5765 for crate::model::ListPaymentsRequest
5766{
5767}
5768impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentsRequest>
5769 for crate::model::ListPaymentsRequest
5770{
5771 fn into_into_dart(self) -> crate::model::ListPaymentsRequest {
5772 self
5773 }
5774}
5775impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNInvoice> {
5777 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5778 [
5779 self.0.bolt11.into_into_dart().into_dart(),
5780 self.0.network.into_into_dart().into_dart(),
5781 self.0.payee_pubkey.into_into_dart().into_dart(),
5782 self.0.payment_hash.into_into_dart().into_dart(),
5783 self.0.description.into_into_dart().into_dart(),
5784 self.0.description_hash.into_into_dart().into_dart(),
5785 self.0.amount_msat.into_into_dart().into_dart(),
5786 self.0.timestamp.into_into_dart().into_dart(),
5787 self.0.expiry.into_into_dart().into_dart(),
5788 self.0.routing_hints.into_into_dart().into_dart(),
5789 self.0.payment_secret.into_into_dart().into_dart(),
5790 self.0
5791 .min_final_cltv_expiry_delta
5792 .into_into_dart()
5793 .into_dart(),
5794 ]
5795 .into_dart()
5796 }
5797}
5798impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5799 for FrbWrapper<crate::bindings::LNInvoice>
5800{
5801}
5802impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNInvoice>>
5803 for crate::bindings::LNInvoice
5804{
5805 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNInvoice> {
5806 self.into()
5807 }
5808}
5809impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNOffer> {
5811 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5812 [
5813 self.0.offer.into_into_dart().into_dart(),
5814 self.0.chains.into_into_dart().into_dart(),
5815 self.0.min_amount.into_into_dart().into_dart(),
5816 self.0.description.into_into_dart().into_dart(),
5817 self.0.absolute_expiry.into_into_dart().into_dart(),
5818 self.0.issuer.into_into_dart().into_dart(),
5819 self.0.signing_pubkey.into_into_dart().into_dart(),
5820 self.0.paths.into_into_dart().into_dart(),
5821 ]
5822 .into_dart()
5823 }
5824}
5825impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5826 for FrbWrapper<crate::bindings::LNOffer>
5827{
5828}
5829impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNOffer>>
5830 for crate::bindings::LNOffer
5831{
5832 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNOffer> {
5833 self.into()
5834 }
5835}
5836impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5838 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5839 [self.0.blinded_hops.into_into_dart().into_dart()].into_dart()
5840 }
5841}
5842impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5843 for FrbWrapper<crate::bindings::LnOfferBlindedPath>
5844{
5845}
5846impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnOfferBlindedPath>>
5847 for crate::bindings::LnOfferBlindedPath
5848{
5849 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5850 self.into()
5851 }
5852}
5853impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlAuthError {
5855 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5856 match self {
5857 crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
5858 [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
5859 }
5860 crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
5861 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5862 }
5863 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
5864 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5865 }
5866 _ => {
5867 unimplemented!("");
5868 }
5869 }
5870 }
5871}
5872impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5873 for crate::bindings::duplicates::LnUrlAuthError
5874{
5875}
5876impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlAuthError>
5877 for crate::bindings::duplicates::LnUrlAuthError
5878{
5879 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlAuthError {
5880 self
5881 }
5882}
5883impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5885 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5886 [
5887 self.0.k1.into_into_dart().into_dart(),
5888 self.0.action.into_into_dart().into_dart(),
5889 self.0.domain.into_into_dart().into_dart(),
5890 self.0.url.into_into_dart().into_dart(),
5891 ]
5892 .into_dart()
5893 }
5894}
5895impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5896 for FrbWrapper<crate::bindings::LnUrlAuthRequestData>
5897{
5898}
5899impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlAuthRequestData>>
5900 for crate::bindings::LnUrlAuthRequestData
5901{
5902 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5903 self.into()
5904 }
5905}
5906impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlCallbackStatus {
5908 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5909 match self {
5910 crate::bindings::duplicates::LnUrlCallbackStatus::Ok => [0.into_dart()].into_dart(),
5911 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
5912 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
5913 }
5914 _ => {
5915 unimplemented!("");
5916 }
5917 }
5918 }
5919}
5920impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5921 for crate::bindings::duplicates::LnUrlCallbackStatus
5922{
5923}
5924impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlCallbackStatus>
5925 for crate::bindings::duplicates::LnUrlCallbackStatus
5926{
5927 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
5928 self
5929 }
5930}
5931impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlErrorData> {
5933 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5934 [self.0.reason.into_into_dart().into_dart()].into_dart()
5935 }
5936}
5937impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5938 for FrbWrapper<crate::bindings::LnUrlErrorData>
5939{
5940}
5941impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlErrorData>>
5942 for crate::bindings::LnUrlErrorData
5943{
5944 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlErrorData> {
5945 self.into()
5946 }
5947}
5948impl flutter_rust_bridge::IntoDart for crate::model::LnUrlInfo {
5950 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5951 [
5952 self.ln_address.into_into_dart().into_dart(),
5953 self.lnurl_pay_comment.into_into_dart().into_dart(),
5954 self.lnurl_pay_domain.into_into_dart().into_dart(),
5955 self.lnurl_pay_metadata.into_into_dart().into_dart(),
5956 self.lnurl_pay_success_action.into_into_dart().into_dart(),
5957 self.lnurl_pay_unprocessed_success_action
5958 .into_into_dart()
5959 .into_dart(),
5960 self.lnurl_withdraw_endpoint.into_into_dart().into_dart(),
5961 ]
5962 .into_dart()
5963 }
5964}
5965impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlInfo {}
5966impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlInfo> for crate::model::LnUrlInfo {
5967 fn into_into_dart(self) -> crate::model::LnUrlInfo {
5968 self
5969 }
5970}
5971impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlPayError {
5973 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5974 match self {
5975 crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => [0.into_dart()].into_dart(),
5976 crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
5977 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5978 }
5979 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
5980 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5981 }
5982 crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
5983 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
5984 }
5985 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
5986 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
5987 }
5988 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
5989 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
5990 }
5991 crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
5992 [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
5993 }
5994 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
5995 [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
5996 }
5997 crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
5998 [8.into_dart(), err.into_into_dart().into_dart()].into_dart()
5999 }
6000 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
6001 [9.into_dart(), err.into_into_dart().into_dart()].into_dart()
6002 }
6003 crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
6004 [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6005 }
6006 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
6007 [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6008 }
6009 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
6010 [12.into_dart(), err.into_into_dart().into_dart()].into_dart()
6011 }
6012 _ => {
6013 unimplemented!("");
6014 }
6015 }
6016 }
6017}
6018impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6019 for crate::bindings::duplicates::LnUrlPayError
6020{
6021}
6022impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlPayError>
6023 for crate::bindings::duplicates::LnUrlPayError
6024{
6025 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlPayError {
6026 self
6027 }
6028}
6029impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6031 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6032 [
6033 self.0.payment_hash.into_into_dart().into_dart(),
6034 self.0.reason.into_into_dart().into_dart(),
6035 ]
6036 .into_dart()
6037 }
6038}
6039impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6040 for FrbWrapper<crate::bindings::LnUrlPayErrorData>
6041{
6042}
6043impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayErrorData>>
6044 for crate::bindings::LnUrlPayErrorData
6045{
6046 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6047 self.into()
6048 }
6049}
6050impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayRequest {
6052 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6053 [self.prepare_response.into_into_dart().into_dart()].into_dart()
6054 }
6055}
6056impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayRequest {}
6057impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayRequest>
6058 for crate::model::LnUrlPayRequest
6059{
6060 fn into_into_dart(self) -> crate::model::LnUrlPayRequest {
6061 self
6062 }
6063}
6064impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6066 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6067 [
6068 self.0.callback.into_into_dart().into_dart(),
6069 self.0.min_sendable.into_into_dart().into_dart(),
6070 self.0.max_sendable.into_into_dart().into_dart(),
6071 self.0.metadata_str.into_into_dart().into_dart(),
6072 self.0.comment_allowed.into_into_dart().into_dart(),
6073 self.0.domain.into_into_dart().into_dart(),
6074 self.0.allows_nostr.into_into_dart().into_dart(),
6075 self.0.nostr_pubkey.into_into_dart().into_dart(),
6076 self.0.ln_address.into_into_dart().into_dart(),
6077 ]
6078 .into_dart()
6079 }
6080}
6081impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6082 for FrbWrapper<crate::bindings::LnUrlPayRequestData>
6083{
6084}
6085impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayRequestData>>
6086 for crate::bindings::LnUrlPayRequestData
6087{
6088 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6089 self.into()
6090 }
6091}
6092impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayResult {
6094 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6095 match self {
6096 crate::model::LnUrlPayResult::EndpointSuccess { data } => {
6097 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6098 }
6099 crate::model::LnUrlPayResult::EndpointError { data } => {
6100 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6101 }
6102 crate::model::LnUrlPayResult::PayError { data } => {
6103 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6104 }
6105 _ => {
6106 unimplemented!("");
6107 }
6108 }
6109 }
6110}
6111impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayResult {}
6112impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayResult>
6113 for crate::model::LnUrlPayResult
6114{
6115 fn into_into_dart(self) -> crate::model::LnUrlPayResult {
6116 self
6117 }
6118}
6119impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPaySuccessData {
6121 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6122 [
6123 self.payment.into_into_dart().into_dart(),
6124 self.success_action.into_into_dart().into_dart(),
6125 ]
6126 .into_dart()
6127 }
6128}
6129impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6130 for crate::model::LnUrlPaySuccessData
6131{
6132}
6133impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPaySuccessData>
6134 for crate::model::LnUrlPaySuccessData
6135{
6136 fn into_into_dart(self) -> crate::model::LnUrlPaySuccessData {
6137 self
6138 }
6139}
6140impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawError {
6142 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6143 match self {
6144 crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
6145 [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
6146 }
6147 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
6148 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
6149 }
6150 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
6151 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
6152 }
6153 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
6154 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
6155 }
6156 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
6157 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6158 }
6159 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
6160 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6161 }
6162 _ => {
6163 unimplemented!("");
6164 }
6165 }
6166 }
6167}
6168impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6169 for crate::bindings::duplicates::LnUrlWithdrawError
6170{
6171}
6172impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawError>
6173 for crate::bindings::duplicates::LnUrlWithdrawError
6174{
6175 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
6176 self
6177 }
6178}
6179impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6181 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6182 [
6183 self.0.data.into_into_dart().into_dart(),
6184 self.0.amount_msat.into_into_dart().into_dart(),
6185 self.0.description.into_into_dart().into_dart(),
6186 ]
6187 .into_dart()
6188 }
6189}
6190impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6191 for FrbWrapper<crate::bindings::LnUrlWithdrawRequest>
6192{
6193}
6194impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequest>>
6195 for crate::bindings::LnUrlWithdrawRequest
6196{
6197 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6198 self.into()
6199 }
6200}
6201impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6203 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6204 [
6205 self.0.callback.into_into_dart().into_dart(),
6206 self.0.k1.into_into_dart().into_dart(),
6207 self.0.default_description.into_into_dart().into_dart(),
6208 self.0.min_withdrawable.into_into_dart().into_dart(),
6209 self.0.max_withdrawable.into_into_dart().into_dart(),
6210 ]
6211 .into_dart()
6212 }
6213}
6214impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6215 for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>
6216{
6217}
6218impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>>
6219 for crate::bindings::LnUrlWithdrawRequestData
6220{
6221 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6222 self.into()
6223 }
6224}
6225impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawResult {
6227 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6228 match self {
6229 crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
6230 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6231 }
6232 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
6233 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6234 }
6235 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
6236 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6237 }
6238 _ => {
6239 unimplemented!("");
6240 }
6241 }
6242 }
6243}
6244impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6245 for crate::bindings::duplicates::LnUrlWithdrawResult
6246{
6247}
6248impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawResult>
6249 for crate::bindings::duplicates::LnUrlWithdrawResult
6250{
6251 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
6252 self
6253 }
6254}
6255impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6257 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6258 [self.invoice.into_into_dart().into_dart()].into_dart()
6259 }
6260}
6261impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6262 for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6263{
6264}
6265impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
6266 for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6267{
6268 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6269 self
6270 }
6271}
6272impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocaleOverrides> {
6274 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6275 [
6276 self.0.locale.into_into_dart().into_dart(),
6277 self.0.spacing.into_into_dart().into_dart(),
6278 self.0.symbol.into_into_dart().into_dart(),
6279 ]
6280 .into_dart()
6281 }
6282}
6283impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6284 for FrbWrapper<crate::bindings::LocaleOverrides>
6285{
6286}
6287impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocaleOverrides>>
6288 for crate::bindings::LocaleOverrides
6289{
6290 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocaleOverrides> {
6291 self.into()
6292 }
6293}
6294impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocalizedName> {
6296 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6297 [
6298 self.0.locale.into_into_dart().into_dart(),
6299 self.0.name.into_into_dart().into_dart(),
6300 ]
6301 .into_dart()
6302 }
6303}
6304impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6305 for FrbWrapper<crate::bindings::LocalizedName>
6306{
6307}
6308impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocalizedName>>
6309 for crate::bindings::LocalizedName
6310{
6311 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocalizedName> {
6312 self.into()
6313 }
6314}
6315impl flutter_rust_bridge::IntoDart for crate::model::LogEntry {
6317 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6318 [
6319 self.line.into_into_dart().into_dart(),
6320 self.level.into_into_dart().into_dart(),
6321 ]
6322 .into_dart()
6323 }
6324}
6325impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LogEntry {}
6326impl flutter_rust_bridge::IntoIntoDart<crate::model::LogEntry> for crate::model::LogEntry {
6327 fn into_into_dart(self) -> crate::model::LogEntry {
6328 self
6329 }
6330}
6331impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::MessageSuccessActionData> {
6333 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6334 [self.0.message.into_into_dart().into_dart()].into_dart()
6335 }
6336}
6337impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6338 for FrbWrapper<crate::bindings::MessageSuccessActionData>
6339{
6340}
6341impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::MessageSuccessActionData>>
6342 for crate::bindings::MessageSuccessActionData
6343{
6344 fn into_into_dart(self) -> FrbWrapper<crate::bindings::MessageSuccessActionData> {
6345 self.into()
6346 }
6347}
6348impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Network> {
6350 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6351 match self.0 {
6352 crate::bindings::Network::Bitcoin => 0.into_dart(),
6353 crate::bindings::Network::Testnet => 1.into_dart(),
6354 crate::bindings::Network::Signet => 2.into_dart(),
6355 crate::bindings::Network::Regtest => 3.into_dart(),
6356 _ => unreachable!(),
6357 }
6358 }
6359}
6360impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6361 for FrbWrapper<crate::bindings::Network>
6362{
6363}
6364impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Network>>
6365 for crate::bindings::Network
6366{
6367 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Network> {
6368 self.into()
6369 }
6370}
6371impl flutter_rust_bridge::IntoDart for crate::model::OnchainPaymentLimitsResponse {
6373 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6374 [
6375 self.send.into_into_dart().into_dart(),
6376 self.receive.into_into_dart().into_dart(),
6377 ]
6378 .into_dart()
6379 }
6380}
6381impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6382 for crate::model::OnchainPaymentLimitsResponse
6383{
6384}
6385impl flutter_rust_bridge::IntoIntoDart<crate::model::OnchainPaymentLimitsResponse>
6386 for crate::model::OnchainPaymentLimitsResponse
6387{
6388 fn into_into_dart(self) -> crate::model::OnchainPaymentLimitsResponse {
6389 self
6390 }
6391}
6392impl flutter_rust_bridge::IntoDart for crate::model::PayAmount {
6394 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6395 match self {
6396 crate::model::PayAmount::Bitcoin {
6397 receiver_amount_sat,
6398 } => [
6399 0.into_dart(),
6400 receiver_amount_sat.into_into_dart().into_dart(),
6401 ]
6402 .into_dart(),
6403 crate::model::PayAmount::Asset {
6404 asset_id,
6405 receiver_amount,
6406 estimate_asset_fees,
6407 pay_with_bitcoin,
6408 } => [
6409 1.into_dart(),
6410 asset_id.into_into_dart().into_dart(),
6411 receiver_amount.into_into_dart().into_dart(),
6412 estimate_asset_fees.into_into_dart().into_dart(),
6413 pay_with_bitcoin.into_into_dart().into_dart(),
6414 ]
6415 .into_dart(),
6416 crate::model::PayAmount::Drain => [2.into_dart()].into_dart(),
6417 _ => {
6418 unimplemented!("");
6419 }
6420 }
6421 }
6422}
6423impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PayAmount {}
6424impl flutter_rust_bridge::IntoIntoDart<crate::model::PayAmount> for crate::model::PayAmount {
6425 fn into_into_dart(self) -> crate::model::PayAmount {
6426 self
6427 }
6428}
6429impl flutter_rust_bridge::IntoDart for crate::model::PayOnchainRequest {
6431 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6432 [
6433 self.address.into_into_dart().into_dart(),
6434 self.prepare_response.into_into_dart().into_dart(),
6435 ]
6436 .into_dart()
6437 }
6438}
6439impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6440 for crate::model::PayOnchainRequest
6441{
6442}
6443impl flutter_rust_bridge::IntoIntoDart<crate::model::PayOnchainRequest>
6444 for crate::model::PayOnchainRequest
6445{
6446 fn into_into_dart(self) -> crate::model::PayOnchainRequest {
6447 self
6448 }
6449}
6450impl flutter_rust_bridge::IntoDart for crate::model::Payment {
6452 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6453 [
6454 self.destination.into_into_dart().into_dart(),
6455 self.tx_id.into_into_dart().into_dart(),
6456 self.unblinding_data.into_into_dart().into_dart(),
6457 self.timestamp.into_into_dart().into_dart(),
6458 self.amount_sat.into_into_dart().into_dart(),
6459 self.fees_sat.into_into_dart().into_dart(),
6460 self.swapper_fees_sat.into_into_dart().into_dart(),
6461 self.payment_type.into_into_dart().into_dart(),
6462 self.status.into_into_dart().into_dart(),
6463 self.details.into_into_dart().into_dart(),
6464 ]
6465 .into_dart()
6466 }
6467}
6468impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Payment {}
6469impl flutter_rust_bridge::IntoIntoDart<crate::model::Payment> for crate::model::Payment {
6470 fn into_into_dart(self) -> crate::model::Payment {
6471 self
6472 }
6473}
6474impl flutter_rust_bridge::IntoDart for crate::model::PaymentDetails {
6476 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6477 match self {
6478 crate::model::PaymentDetails::Lightning {
6479 swap_id,
6480 description,
6481 liquid_expiration_blockheight,
6482 preimage,
6483 invoice,
6484 bolt12_offer,
6485 payment_hash,
6486 destination_pubkey,
6487 lnurl_info,
6488 bip353_address,
6489 payer_note,
6490 claim_tx_id,
6491 refund_tx_id,
6492 refund_tx_amount_sat,
6493 } => [
6494 0.into_dart(),
6495 swap_id.into_into_dart().into_dart(),
6496 description.into_into_dart().into_dart(),
6497 liquid_expiration_blockheight.into_into_dart().into_dart(),
6498 preimage.into_into_dart().into_dart(),
6499 invoice.into_into_dart().into_dart(),
6500 bolt12_offer.into_into_dart().into_dart(),
6501 payment_hash.into_into_dart().into_dart(),
6502 destination_pubkey.into_into_dart().into_dart(),
6503 lnurl_info.into_into_dart().into_dart(),
6504 bip353_address.into_into_dart().into_dart(),
6505 payer_note.into_into_dart().into_dart(),
6506 claim_tx_id.into_into_dart().into_dart(),
6507 refund_tx_id.into_into_dart().into_dart(),
6508 refund_tx_amount_sat.into_into_dart().into_dart(),
6509 ]
6510 .into_dart(),
6511 crate::model::PaymentDetails::Liquid {
6512 destination,
6513 description,
6514 asset_id,
6515 asset_info,
6516 lnurl_info,
6517 bip353_address,
6518 payer_note,
6519 } => [
6520 1.into_dart(),
6521 destination.into_into_dart().into_dart(),
6522 description.into_into_dart().into_dart(),
6523 asset_id.into_into_dart().into_dart(),
6524 asset_info.into_into_dart().into_dart(),
6525 lnurl_info.into_into_dart().into_dart(),
6526 bip353_address.into_into_dart().into_dart(),
6527 payer_note.into_into_dart().into_dart(),
6528 ]
6529 .into_dart(),
6530 crate::model::PaymentDetails::Bitcoin {
6531 swap_id,
6532 bitcoin_address,
6533 description,
6534 auto_accepted_fees,
6535 liquid_expiration_blockheight,
6536 bitcoin_expiration_blockheight,
6537 lockup_tx_id,
6538 claim_tx_id,
6539 refund_tx_id,
6540 refund_tx_amount_sat,
6541 } => [
6542 2.into_dart(),
6543 swap_id.into_into_dart().into_dart(),
6544 bitcoin_address.into_into_dart().into_dart(),
6545 description.into_into_dart().into_dart(),
6546 auto_accepted_fees.into_into_dart().into_dart(),
6547 liquid_expiration_blockheight.into_into_dart().into_dart(),
6548 bitcoin_expiration_blockheight.into_into_dart().into_dart(),
6549 lockup_tx_id.into_into_dart().into_dart(),
6550 claim_tx_id.into_into_dart().into_dart(),
6551 refund_tx_id.into_into_dart().into_dart(),
6552 refund_tx_amount_sat.into_into_dart().into_dart(),
6553 ]
6554 .into_dart(),
6555 _ => {
6556 unimplemented!("");
6557 }
6558 }
6559 }
6560}
6561impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentDetails {}
6562impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentDetails>
6563 for crate::model::PaymentDetails
6564{
6565 fn into_into_dart(self) -> crate::model::PaymentDetails {
6566 self
6567 }
6568}
6569impl flutter_rust_bridge::IntoDart for crate::error::PaymentError {
6571 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6572 match self {
6573 crate::error::PaymentError::AlreadyClaimed => [0.into_dart()].into_dart(),
6574 crate::error::PaymentError::AlreadyPaid => [1.into_dart()].into_dart(),
6575 crate::error::PaymentError::PaymentInProgress => [2.into_dart()].into_dart(),
6576 crate::error::PaymentError::AmountOutOfRange { min, max } => [
6577 3.into_dart(),
6578 min.into_into_dart().into_dart(),
6579 max.into_into_dart().into_dart(),
6580 ]
6581 .into_dart(),
6582 crate::error::PaymentError::AmountMissing { err } => {
6583 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6584 }
6585 crate::error::PaymentError::AssetError { err } => {
6586 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6587 }
6588 crate::error::PaymentError::InvalidNetwork { err } => {
6589 [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
6590 }
6591 crate::error::PaymentError::Generic { err } => {
6592 [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
6593 }
6594 crate::error::PaymentError::InvalidOrExpiredFees => [8.into_dart()].into_dart(),
6595 crate::error::PaymentError::InsufficientFunds => [9.into_dart()].into_dart(),
6596 crate::error::PaymentError::InvalidDescription { err } => {
6597 [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6598 }
6599 crate::error::PaymentError::InvalidInvoice { err } => {
6600 [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6601 }
6602 crate::error::PaymentError::InvalidPreimage => [12.into_dart()].into_dart(),
6603 crate::error::PaymentError::PairsNotFound => [13.into_dart()].into_dart(),
6604 crate::error::PaymentError::PaymentTimeout => [14.into_dart()].into_dart(),
6605 crate::error::PaymentError::PersistError => [15.into_dart()].into_dart(),
6606 crate::error::PaymentError::ReceiveError { err } => {
6607 [16.into_dart(), err.into_into_dart().into_dart()].into_dart()
6608 }
6609 crate::error::PaymentError::Refunded { err, refund_tx_id } => [
6610 17.into_dart(),
6611 err.into_into_dart().into_dart(),
6612 refund_tx_id.into_into_dart().into_dart(),
6613 ]
6614 .into_dart(),
6615 crate::error::PaymentError::SelfTransferNotSupported => [18.into_dart()].into_dart(),
6616 crate::error::PaymentError::SendError { err } => {
6617 [19.into_dart(), err.into_into_dart().into_dart()].into_dart()
6618 }
6619 crate::error::PaymentError::SignerError { err } => {
6620 [20.into_dart(), err.into_into_dart().into_dart()].into_dart()
6621 }
6622 _ => {
6623 unimplemented!("");
6624 }
6625 }
6626 }
6627}
6628impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::PaymentError {}
6629impl flutter_rust_bridge::IntoIntoDart<crate::error::PaymentError> for crate::error::PaymentError {
6630 fn into_into_dart(self) -> crate::error::PaymentError {
6631 self
6632 }
6633}
6634impl flutter_rust_bridge::IntoDart for crate::model::PaymentMethod {
6636 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6637 match self {
6638 Self::Lightning => 0.into_dart(),
6639 Self::Bolt11Invoice => 1.into_dart(),
6640 Self::Bolt12Offer => 2.into_dart(),
6641 Self::BitcoinAddress => 3.into_dart(),
6642 Self::LiquidAddress => 4.into_dart(),
6643 _ => unreachable!(),
6644 }
6645 }
6646}
6647impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentMethod {}
6648impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentMethod>
6649 for crate::model::PaymentMethod
6650{
6651 fn into_into_dart(self) -> crate::model::PaymentMethod {
6652 self
6653 }
6654}
6655impl flutter_rust_bridge::IntoDart for crate::model::PaymentState {
6657 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6658 match self {
6659 Self::Created => 0.into_dart(),
6660 Self::Pending => 1.into_dart(),
6661 Self::Complete => 2.into_dart(),
6662 Self::Failed => 3.into_dart(),
6663 Self::TimedOut => 4.into_dart(),
6664 Self::Refundable => 5.into_dart(),
6665 Self::RefundPending => 6.into_dart(),
6666 Self::WaitingFeeAcceptance => 7.into_dart(),
6667 _ => unreachable!(),
6668 }
6669 }
6670}
6671impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentState {}
6672impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentState> for crate::model::PaymentState {
6673 fn into_into_dart(self) -> crate::model::PaymentState {
6674 self
6675 }
6676}
6677impl flutter_rust_bridge::IntoDart for crate::model::PaymentType {
6679 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6680 match self {
6681 Self::Receive => 0.into_dart(),
6682 Self::Send => 1.into_dart(),
6683 _ => unreachable!(),
6684 }
6685 }
6686}
6687impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentType {}
6688impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentType> for crate::model::PaymentType {
6689 fn into_into_dart(self) -> crate::model::PaymentType {
6690 self
6691 }
6692}
6693impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinRequest {
6695 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6696 [
6697 self.provider.into_into_dart().into_dart(),
6698 self.amount_sat.into_into_dart().into_dart(),
6699 ]
6700 .into_dart()
6701 }
6702}
6703impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6704 for crate::model::PrepareBuyBitcoinRequest
6705{
6706}
6707impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinRequest>
6708 for crate::model::PrepareBuyBitcoinRequest
6709{
6710 fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinRequest {
6711 self
6712 }
6713}
6714impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinResponse {
6716 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6717 [
6718 self.provider.into_into_dart().into_dart(),
6719 self.amount_sat.into_into_dart().into_dart(),
6720 self.fees_sat.into_into_dart().into_dart(),
6721 ]
6722 .into_dart()
6723 }
6724}
6725impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6726 for crate::model::PrepareBuyBitcoinResponse
6727{
6728}
6729impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinResponse>
6730 for crate::model::PrepareBuyBitcoinResponse
6731{
6732 fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinResponse {
6733 self
6734 }
6735}
6736impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayRequest {
6738 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6739 [
6740 self.data.into_into_dart().into_dart(),
6741 self.amount.into_into_dart().into_dart(),
6742 self.bip353_address.into_into_dart().into_dart(),
6743 self.comment.into_into_dart().into_dart(),
6744 self.validate_success_action_url
6745 .into_into_dart()
6746 .into_dart(),
6747 ]
6748 .into_dart()
6749 }
6750}
6751impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6752 for crate::model::PrepareLnUrlPayRequest
6753{
6754}
6755impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayRequest>
6756 for crate::model::PrepareLnUrlPayRequest
6757{
6758 fn into_into_dart(self) -> crate::model::PrepareLnUrlPayRequest {
6759 self
6760 }
6761}
6762impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayResponse {
6764 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6765 [
6766 self.destination.into_into_dart().into_dart(),
6767 self.fees_sat.into_into_dart().into_dart(),
6768 self.data.into_into_dart().into_dart(),
6769 self.amount.into_into_dart().into_dart(),
6770 self.comment.into_into_dart().into_dart(),
6771 self.success_action.into_into_dart().into_dart(),
6772 ]
6773 .into_dart()
6774 }
6775}
6776impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6777 for crate::model::PrepareLnUrlPayResponse
6778{
6779}
6780impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayResponse>
6781 for crate::model::PrepareLnUrlPayResponse
6782{
6783 fn into_into_dart(self) -> crate::model::PrepareLnUrlPayResponse {
6784 self
6785 }
6786}
6787impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainRequest {
6789 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6790 [
6791 self.amount.into_into_dart().into_dart(),
6792 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6793 ]
6794 .into_dart()
6795 }
6796}
6797impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6798 for crate::model::PreparePayOnchainRequest
6799{
6800}
6801impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainRequest>
6802 for crate::model::PreparePayOnchainRequest
6803{
6804 fn into_into_dart(self) -> crate::model::PreparePayOnchainRequest {
6805 self
6806 }
6807}
6808impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainResponse {
6810 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6811 [
6812 self.receiver_amount_sat.into_into_dart().into_dart(),
6813 self.claim_fees_sat.into_into_dart().into_dart(),
6814 self.total_fees_sat.into_into_dart().into_dart(),
6815 ]
6816 .into_dart()
6817 }
6818}
6819impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6820 for crate::model::PreparePayOnchainResponse
6821{
6822}
6823impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainResponse>
6824 for crate::model::PreparePayOnchainResponse
6825{
6826 fn into_into_dart(self) -> crate::model::PreparePayOnchainResponse {
6827 self
6828 }
6829}
6830impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveRequest {
6832 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6833 [
6834 self.payment_method.into_into_dart().into_dart(),
6835 self.amount.into_into_dart().into_dart(),
6836 ]
6837 .into_dart()
6838 }
6839}
6840impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6841 for crate::model::PrepareReceiveRequest
6842{
6843}
6844impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveRequest>
6845 for crate::model::PrepareReceiveRequest
6846{
6847 fn into_into_dart(self) -> crate::model::PrepareReceiveRequest {
6848 self
6849 }
6850}
6851impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveResponse {
6853 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6854 [
6855 self.payment_method.into_into_dart().into_dart(),
6856 self.fees_sat.into_into_dart().into_dart(),
6857 self.amount.into_into_dart().into_dart(),
6858 self.min_payer_amount_sat.into_into_dart().into_dart(),
6859 self.max_payer_amount_sat.into_into_dart().into_dart(),
6860 self.swapper_feerate.into_into_dart().into_dart(),
6861 ]
6862 .into_dart()
6863 }
6864}
6865impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6866 for crate::model::PrepareReceiveResponse
6867{
6868}
6869impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveResponse>
6870 for crate::model::PrepareReceiveResponse
6871{
6872 fn into_into_dart(self) -> crate::model::PrepareReceiveResponse {
6873 self
6874 }
6875}
6876impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundRequest {
6878 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6879 [
6880 self.swap_address.into_into_dart().into_dart(),
6881 self.refund_address.into_into_dart().into_dart(),
6882 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6883 ]
6884 .into_dart()
6885 }
6886}
6887impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6888 for crate::model::PrepareRefundRequest
6889{
6890}
6891impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundRequest>
6892 for crate::model::PrepareRefundRequest
6893{
6894 fn into_into_dart(self) -> crate::model::PrepareRefundRequest {
6895 self
6896 }
6897}
6898impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundResponse {
6900 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6901 [
6902 self.tx_vsize.into_into_dart().into_dart(),
6903 self.tx_fee_sat.into_into_dart().into_dart(),
6904 self.last_refund_tx_id.into_into_dart().into_dart(),
6905 ]
6906 .into_dart()
6907 }
6908}
6909impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6910 for crate::model::PrepareRefundResponse
6911{
6912}
6913impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundResponse>
6914 for crate::model::PrepareRefundResponse
6915{
6916 fn into_into_dart(self) -> crate::model::PrepareRefundResponse {
6917 self
6918 }
6919}
6920impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendRequest {
6922 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6923 [
6924 self.destination.into_into_dart().into_dart(),
6925 self.amount.into_into_dart().into_dart(),
6926 ]
6927 .into_dart()
6928 }
6929}
6930impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6931 for crate::model::PrepareSendRequest
6932{
6933}
6934impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendRequest>
6935 for crate::model::PrepareSendRequest
6936{
6937 fn into_into_dart(self) -> crate::model::PrepareSendRequest {
6938 self
6939 }
6940}
6941impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendResponse {
6943 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6944 [
6945 self.destination.into_into_dart().into_dart(),
6946 self.amount.into_into_dart().into_dart(),
6947 self.fees_sat.into_into_dart().into_dart(),
6948 self.estimated_asset_fees.into_into_dart().into_dart(),
6949 ]
6950 .into_dart()
6951 }
6952}
6953impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6954 for crate::model::PrepareSendResponse
6955{
6956}
6957impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendResponse>
6958 for crate::model::PrepareSendResponse
6959{
6960 fn into_into_dart(self) -> crate::model::PrepareSendResponse {
6961 self
6962 }
6963}
6964impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Rate> {
6966 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6967 [
6968 self.0.coin.into_into_dart().into_dart(),
6969 self.0.value.into_into_dart().into_dart(),
6970 ]
6971 .into_dart()
6972 }
6973}
6974impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6975 for FrbWrapper<crate::bindings::Rate>
6976{
6977}
6978impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Rate>>
6979 for crate::bindings::Rate
6980{
6981 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Rate> {
6982 self.into()
6983 }
6984}
6985impl flutter_rust_bridge::IntoDart for crate::model::ReceiveAmount {
6987 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6988 match self {
6989 crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
6990 [0.into_dart(), payer_amount_sat.into_into_dart().into_dart()].into_dart()
6991 }
6992 crate::model::ReceiveAmount::Asset {
6993 asset_id,
6994 payer_amount,
6995 } => [
6996 1.into_dart(),
6997 asset_id.into_into_dart().into_dart(),
6998 payer_amount.into_into_dart().into_dart(),
6999 ]
7000 .into_dart(),
7001 _ => {
7002 unimplemented!("");
7003 }
7004 }
7005 }
7006}
7007impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ReceiveAmount {}
7008impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceiveAmount>
7009 for crate::model::ReceiveAmount
7010{
7011 fn into_into_dart(self) -> crate::model::ReceiveAmount {
7012 self
7013 }
7014}
7015impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentRequest {
7017 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7018 [
7019 self.prepare_response.into_into_dart().into_dart(),
7020 self.description.into_into_dart().into_dart(),
7021 self.use_description_hash.into_into_dart().into_dart(),
7022 self.payer_note.into_into_dart().into_dart(),
7023 ]
7024 .into_dart()
7025 }
7026}
7027impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7028 for crate::model::ReceivePaymentRequest
7029{
7030}
7031impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentRequest>
7032 for crate::model::ReceivePaymentRequest
7033{
7034 fn into_into_dart(self) -> crate::model::ReceivePaymentRequest {
7035 self
7036 }
7037}
7038impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentResponse {
7040 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7041 [self.destination.into_into_dart().into_dart()].into_dart()
7042 }
7043}
7044impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7045 for crate::model::ReceivePaymentResponse
7046{
7047}
7048impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentResponse>
7049 for crate::model::ReceivePaymentResponse
7050{
7051 fn into_into_dart(self) -> crate::model::ReceivePaymentResponse {
7052 self
7053 }
7054}
7055impl flutter_rust_bridge::IntoDart for crate::model::RecommendedFees {
7057 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7058 [
7059 self.fastest_fee.into_into_dart().into_dart(),
7060 self.half_hour_fee.into_into_dart().into_dart(),
7061 self.hour_fee.into_into_dart().into_dart(),
7062 self.economy_fee.into_into_dart().into_dart(),
7063 self.minimum_fee.into_into_dart().into_dart(),
7064 ]
7065 .into_dart()
7066 }
7067}
7068impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RecommendedFees {}
7069impl flutter_rust_bridge::IntoIntoDart<crate::model::RecommendedFees>
7070 for crate::model::RecommendedFees
7071{
7072 fn into_into_dart(self) -> crate::model::RecommendedFees {
7073 self
7074 }
7075}
7076impl flutter_rust_bridge::IntoDart for crate::model::RefundRequest {
7078 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7079 [
7080 self.swap_address.into_into_dart().into_dart(),
7081 self.refund_address.into_into_dart().into_dart(),
7082 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
7083 ]
7084 .into_dart()
7085 }
7086}
7087impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundRequest {}
7088impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundRequest>
7089 for crate::model::RefundRequest
7090{
7091 fn into_into_dart(self) -> crate::model::RefundRequest {
7092 self
7093 }
7094}
7095impl flutter_rust_bridge::IntoDart for crate::model::RefundResponse {
7097 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7098 [self.refund_tx_id.into_into_dart().into_dart()].into_dart()
7099 }
7100}
7101impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundResponse {}
7102impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundResponse>
7103 for crate::model::RefundResponse
7104{
7105 fn into_into_dart(self) -> crate::model::RefundResponse {
7106 self
7107 }
7108}
7109impl flutter_rust_bridge::IntoDart for crate::model::RefundableSwap {
7111 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7112 [
7113 self.swap_address.into_into_dart().into_dart(),
7114 self.timestamp.into_into_dart().into_dart(),
7115 self.amount_sat.into_into_dart().into_dart(),
7116 self.last_refund_tx_id.into_into_dart().into_dart(),
7117 ]
7118 .into_dart()
7119 }
7120}
7121impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundableSwap {}
7122impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundableSwap>
7123 for crate::model::RefundableSwap
7124{
7125 fn into_into_dart(self) -> crate::model::RefundableSwap {
7126 self
7127 }
7128}
7129impl flutter_rust_bridge::IntoDart for crate::model::RestoreRequest {
7131 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7132 [self.backup_path.into_into_dart().into_dart()].into_dart()
7133 }
7134}
7135impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RestoreRequest {}
7136impl flutter_rust_bridge::IntoIntoDart<crate::model::RestoreRequest>
7137 for crate::model::RestoreRequest
7138{
7139 fn into_into_dart(self) -> crate::model::RestoreRequest {
7140 self
7141 }
7142}
7143impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHint> {
7145 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7146 [self.0.hops.into_into_dart().into_dart()].into_dart()
7147 }
7148}
7149impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7150 for FrbWrapper<crate::bindings::RouteHint>
7151{
7152}
7153impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHint>>
7154 for crate::bindings::RouteHint
7155{
7156 fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHint> {
7157 self.into()
7158 }
7159}
7160impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHintHop> {
7162 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7163 [
7164 self.0.src_node_id.into_into_dart().into_dart(),
7165 self.0.short_channel_id.into_into_dart().into_dart(),
7166 self.0.fees_base_msat.into_into_dart().into_dart(),
7167 self.0
7168 .fees_proportional_millionths
7169 .into_into_dart()
7170 .into_dart(),
7171 self.0.cltv_expiry_delta.into_into_dart().into_dart(),
7172 self.0.htlc_minimum_msat.into_into_dart().into_dart(),
7173 self.0.htlc_maximum_msat.into_into_dart().into_dart(),
7174 ]
7175 .into_dart()
7176 }
7177}
7178impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7179 for FrbWrapper<crate::bindings::RouteHintHop>
7180{
7181}
7182impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHintHop>>
7183 for crate::bindings::RouteHintHop
7184{
7185 fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHintHop> {
7186 self.into()
7187 }
7188}
7189impl flutter_rust_bridge::IntoDart for crate::error::SdkError {
7191 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7192 match self {
7193 crate::error::SdkError::AlreadyStarted => [0.into_dart()].into_dart(),
7194 crate::error::SdkError::Generic { err } => {
7195 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
7196 }
7197 crate::error::SdkError::NotStarted => [2.into_dart()].into_dart(),
7198 crate::error::SdkError::ServiceConnectivity { err } => {
7199 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
7200 }
7201 _ => {
7202 unimplemented!("");
7203 }
7204 }
7205 }
7206}
7207impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::SdkError {}
7208impl flutter_rust_bridge::IntoIntoDart<crate::error::SdkError> for crate::error::SdkError {
7209 fn into_into_dart(self) -> crate::error::SdkError {
7210 self
7211 }
7212}
7213impl flutter_rust_bridge::IntoDart for crate::model::SdkEvent {
7215 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7216 match self {
7217 crate::model::SdkEvent::PaymentFailed { details } => {
7218 [0.into_dart(), details.into_into_dart().into_dart()].into_dart()
7219 }
7220 crate::model::SdkEvent::PaymentPending { details } => {
7221 [1.into_dart(), details.into_into_dart().into_dart()].into_dart()
7222 }
7223 crate::model::SdkEvent::PaymentRefundable { details } => {
7224 [2.into_dart(), details.into_into_dart().into_dart()].into_dart()
7225 }
7226 crate::model::SdkEvent::PaymentRefunded { details } => {
7227 [3.into_dart(), details.into_into_dart().into_dart()].into_dart()
7228 }
7229 crate::model::SdkEvent::PaymentRefundPending { details } => {
7230 [4.into_dart(), details.into_into_dart().into_dart()].into_dart()
7231 }
7232 crate::model::SdkEvent::PaymentSucceeded { details } => {
7233 [5.into_dart(), details.into_into_dart().into_dart()].into_dart()
7234 }
7235 crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
7236 [6.into_dart(), details.into_into_dart().into_dart()].into_dart()
7237 }
7238 crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
7239 [7.into_dart(), details.into_into_dart().into_dart()].into_dart()
7240 }
7241 crate::model::SdkEvent::Synced => [8.into_dart()].into_dart(),
7242 crate::model::SdkEvent::DataSynced {
7243 did_pull_new_records,
7244 } => [
7245 9.into_dart(),
7246 did_pull_new_records.into_into_dart().into_dart(),
7247 ]
7248 .into_dart(),
7249 _ => {
7250 unimplemented!("");
7251 }
7252 }
7253 }
7254}
7255impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SdkEvent {}
7256impl flutter_rust_bridge::IntoIntoDart<crate::model::SdkEvent> for crate::model::SdkEvent {
7257 fn into_into_dart(self) -> crate::model::SdkEvent {
7258 self
7259 }
7260}
7261impl flutter_rust_bridge::IntoDart for crate::model::SendDestination {
7263 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7264 match self {
7265 crate::model::SendDestination::LiquidAddress {
7266 address_data,
7267 bip353_address,
7268 } => [
7269 0.into_dart(),
7270 address_data.into_into_dart().into_dart(),
7271 bip353_address.into_into_dart().into_dart(),
7272 ]
7273 .into_dart(),
7274 crate::model::SendDestination::Bolt11 {
7275 invoice,
7276 bip353_address,
7277 } => [
7278 1.into_dart(),
7279 invoice.into_into_dart().into_dart(),
7280 bip353_address.into_into_dart().into_dart(),
7281 ]
7282 .into_dart(),
7283 crate::model::SendDestination::Bolt12 {
7284 offer,
7285 receiver_amount_sat,
7286 bip353_address,
7287 } => [
7288 2.into_dart(),
7289 offer.into_into_dart().into_dart(),
7290 receiver_amount_sat.into_into_dart().into_dart(),
7291 bip353_address.into_into_dart().into_dart(),
7292 ]
7293 .into_dart(),
7294 _ => {
7295 unimplemented!("");
7296 }
7297 }
7298 }
7299}
7300impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SendDestination {}
7301impl flutter_rust_bridge::IntoIntoDart<crate::model::SendDestination>
7302 for crate::model::SendDestination
7303{
7304 fn into_into_dart(self) -> crate::model::SendDestination {
7305 self
7306 }
7307}
7308impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentRequest {
7310 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7311 [
7312 self.prepare_response.into_into_dart().into_dart(),
7313 self.use_asset_fees.into_into_dart().into_dart(),
7314 self.payer_note.into_into_dart().into_dart(),
7315 ]
7316 .into_dart()
7317 }
7318}
7319impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7320 for crate::model::SendPaymentRequest
7321{
7322}
7323impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentRequest>
7324 for crate::model::SendPaymentRequest
7325{
7326 fn into_into_dart(self) -> crate::model::SendPaymentRequest {
7327 self
7328 }
7329}
7330impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentResponse {
7332 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7333 [self.payment.into_into_dart().into_dart()].into_dart()
7334 }
7335}
7336impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7337 for crate::model::SendPaymentResponse
7338{
7339}
7340impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentResponse>
7341 for crate::model::SendPaymentResponse
7342{
7343 fn into_into_dart(self) -> crate::model::SendPaymentResponse {
7344 self
7345 }
7346}
7347impl flutter_rust_bridge::IntoDart for crate::model::SignMessageRequest {
7349 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7350 [self.message.into_into_dart().into_dart()].into_dart()
7351 }
7352}
7353impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7354 for crate::model::SignMessageRequest
7355{
7356}
7357impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageRequest>
7358 for crate::model::SignMessageRequest
7359{
7360 fn into_into_dart(self) -> crate::model::SignMessageRequest {
7361 self
7362 }
7363}
7364impl flutter_rust_bridge::IntoDart for crate::model::SignMessageResponse {
7366 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7367 [self.signature.into_into_dart().into_dart()].into_dart()
7368 }
7369}
7370impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7371 for crate::model::SignMessageResponse
7372{
7373}
7374impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageResponse>
7375 for crate::model::SignMessageResponse
7376{
7377 fn into_into_dart(self) -> crate::model::SignMessageResponse {
7378 self
7379 }
7380}
7381impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessAction> {
7383 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7384 match self.0 {
7385 crate::bindings::SuccessAction::Aes { data } => {
7386 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
7387 }
7388 crate::bindings::SuccessAction::Message { data } => {
7389 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7390 }
7391 crate::bindings::SuccessAction::Url { data } => {
7392 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7393 }
7394 _ => {
7395 unimplemented!("");
7396 }
7397 }
7398 }
7399}
7400impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7401 for FrbWrapper<crate::bindings::SuccessAction>
7402{
7403}
7404impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessAction>>
7405 for crate::bindings::SuccessAction
7406{
7407 fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessAction> {
7408 self.into()
7409 }
7410}
7411impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessActionProcessed> {
7413 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7414 match self.0 {
7415 crate::bindings::SuccessActionProcessed::Aes { result } => {
7416 [0.into_dart(), result.into_into_dart().into_dart()].into_dart()
7417 }
7418 crate::bindings::SuccessActionProcessed::Message { data } => {
7419 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7420 }
7421 crate::bindings::SuccessActionProcessed::Url { data } => {
7422 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7423 }
7424 _ => {
7425 unimplemented!("");
7426 }
7427 }
7428 }
7429}
7430impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7431 for FrbWrapper<crate::bindings::SuccessActionProcessed>
7432{
7433}
7434impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessActionProcessed>>
7435 for crate::bindings::SuccessActionProcessed
7436{
7437 fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessActionProcessed> {
7438 self.into()
7439 }
7440}
7441impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Symbol> {
7443 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7444 [
7445 self.0.grapheme.into_into_dart().into_dart(),
7446 self.0.template.into_into_dart().into_dart(),
7447 self.0.rtl.into_into_dart().into_dart(),
7448 self.0.position.into_into_dart().into_dart(),
7449 ]
7450 .into_dart()
7451 }
7452}
7453impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7454 for FrbWrapper<crate::bindings::Symbol>
7455{
7456}
7457impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Symbol>>
7458 for crate::bindings::Symbol
7459{
7460 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Symbol> {
7461 self.into()
7462 }
7463}
7464impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::UrlSuccessActionData> {
7466 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7467 [
7468 self.0.description.into_into_dart().into_dart(),
7469 self.0.url.into_into_dart().into_dart(),
7470 self.0.matches_callback_domain.into_into_dart().into_dart(),
7471 ]
7472 .into_dart()
7473 }
7474}
7475impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7476 for FrbWrapper<crate::bindings::UrlSuccessActionData>
7477{
7478}
7479impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::UrlSuccessActionData>>
7480 for crate::bindings::UrlSuccessActionData
7481{
7482 fn into_into_dart(self) -> FrbWrapper<crate::bindings::UrlSuccessActionData> {
7483 self.into()
7484 }
7485}
7486impl flutter_rust_bridge::IntoDart for crate::model::WalletInfo {
7488 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7489 [
7490 self.balance_sat.into_into_dart().into_dart(),
7491 self.pending_send_sat.into_into_dart().into_dart(),
7492 self.pending_receive_sat.into_into_dart().into_dart(),
7493 self.fingerprint.into_into_dart().into_dart(),
7494 self.pubkey.into_into_dart().into_dart(),
7495 self.asset_balances.into_into_dart().into_dart(),
7496 ]
7497 .into_dart()
7498 }
7499}
7500impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::WalletInfo {}
7501impl flutter_rust_bridge::IntoIntoDart<crate::model::WalletInfo> for crate::model::WalletInfo {
7502 fn into_into_dart(self) -> crate::model::WalletInfo {
7503 self
7504 }
7505}
7506
7507impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
7508 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7510 <String>::sse_encode(format!("{:?}", self), serializer);
7511 }
7512}
7513
7514impl SseEncode for BindingLiquidSdk {
7515 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7517 <RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer);
7518 }
7519}
7520
7521impl SseEncode
7522 for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
7523{
7524 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7526 let (ptr, size) = self.sse_encode_raw();
7527 <usize>::sse_encode(ptr, serializer);
7528 <i32>::sse_encode(size, serializer);
7529 }
7530}
7531
7532impl SseEncode
7533 for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
7534{
7535 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7537 unimplemented!("")
7538 }
7539}
7540
7541impl SseEncode
7542 for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
7543{
7544 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7546 unimplemented!("")
7547 }
7548}
7549
7550impl SseEncode for String {
7551 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7553 <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
7554 }
7555}
7556
7557impl SseEncode for crate::model::AcceptPaymentProposedFeesRequest {
7558 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7560 <crate::model::FetchPaymentProposedFeesResponse>::sse_encode(self.response, serializer);
7561 }
7562}
7563
7564impl SseEncode for crate::bindings::AesSuccessActionData {
7565 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7567 <String>::sse_encode(self.description, serializer);
7568 <String>::sse_encode(self.ciphertext, serializer);
7569 <String>::sse_encode(self.iv, serializer);
7570 }
7571}
7572
7573impl SseEncode for crate::bindings::AesSuccessActionDataDecrypted {
7574 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7576 <String>::sse_encode(self.description, serializer);
7577 <String>::sse_encode(self.plaintext, serializer);
7578 }
7579}
7580
7581impl SseEncode for crate::bindings::AesSuccessActionDataResult {
7582 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7584 match self {
7585 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
7586 <i32>::sse_encode(0, serializer);
7587 <crate::bindings::AesSuccessActionDataDecrypted>::sse_encode(data, serializer);
7588 }
7589 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
7590 <i32>::sse_encode(1, serializer);
7591 <String>::sse_encode(reason, serializer);
7592 }
7593 _ => {
7594 unimplemented!("");
7595 }
7596 }
7597 }
7598}
7599
7600impl SseEncode for crate::bindings::Amount {
7601 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7603 match self {
7604 crate::bindings::Amount::Bitcoin { amount_msat } => {
7605 <i32>::sse_encode(0, serializer);
7606 <u64>::sse_encode(amount_msat, serializer);
7607 }
7608 crate::bindings::Amount::Currency {
7609 iso4217_code,
7610 fractional_amount,
7611 } => {
7612 <i32>::sse_encode(1, serializer);
7613 <String>::sse_encode(iso4217_code, serializer);
7614 <u64>::sse_encode(fractional_amount, serializer);
7615 }
7616 _ => {
7617 unimplemented!("");
7618 }
7619 }
7620 }
7621}
7622
7623impl SseEncode for crate::model::AssetBalance {
7624 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7626 <String>::sse_encode(self.asset_id, serializer);
7627 <u64>::sse_encode(self.balance_sat, serializer);
7628 <Option<String>>::sse_encode(self.name, serializer);
7629 <Option<String>>::sse_encode(self.ticker, serializer);
7630 <Option<f64>>::sse_encode(self.balance, serializer);
7631 }
7632}
7633
7634impl SseEncode for crate::model::AssetInfo {
7635 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7637 <String>::sse_encode(self.name, serializer);
7638 <String>::sse_encode(self.ticker, serializer);
7639 <f64>::sse_encode(self.amount, serializer);
7640 <Option<f64>>::sse_encode(self.fees, serializer);
7641 }
7642}
7643
7644impl SseEncode for crate::model::AssetMetadata {
7645 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7647 <String>::sse_encode(self.asset_id, serializer);
7648 <String>::sse_encode(self.name, serializer);
7649 <String>::sse_encode(self.ticker, serializer);
7650 <u8>::sse_encode(self.precision, serializer);
7651 <Option<String>>::sse_encode(self.fiat_id, serializer);
7652 }
7653}
7654
7655impl SseEncode for crate::model::BackupRequest {
7656 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7658 <Option<String>>::sse_encode(self.backup_path, serializer);
7659 }
7660}
7661
7662impl SseEncode for crate::bindings::BindingEventListener {
7663 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7665 <StreamSink<crate::model::SdkEvent,flutter_rust_bridge::for_generated::DcoCodec>>::sse_encode(self.stream, serializer);
7666 }
7667}
7668
7669impl SseEncode for crate::bindings::BitcoinAddressData {
7670 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7672 <String>::sse_encode(self.address, serializer);
7673 <crate::bindings::Network>::sse_encode(self.network, serializer);
7674 <Option<u64>>::sse_encode(self.amount_sat, serializer);
7675 <Option<String>>::sse_encode(self.label, serializer);
7676 <Option<String>>::sse_encode(self.message, serializer);
7677 }
7678}
7679
7680impl SseEncode for crate::model::BlockchainExplorer {
7681 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7683 match self {
7684 crate::model::BlockchainExplorer::Electrum { url } => {
7685 <i32>::sse_encode(0, serializer);
7686 <String>::sse_encode(url, serializer);
7687 }
7688 crate::model::BlockchainExplorer::Esplora {
7689 url,
7690 use_waterfalls,
7691 } => {
7692 <i32>::sse_encode(1, serializer);
7693 <String>::sse_encode(url, serializer);
7694 <bool>::sse_encode(use_waterfalls, serializer);
7695 }
7696 _ => {
7697 unimplemented!("");
7698 }
7699 }
7700 }
7701}
7702
7703impl SseEncode for crate::model::BlockchainInfo {
7704 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7706 <u32>::sse_encode(self.liquid_tip, serializer);
7707 <u32>::sse_encode(self.bitcoin_tip, serializer);
7708 }
7709}
7710
7711impl SseEncode for bool {
7712 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7714 serializer.cursor.write_u8(self as _).unwrap();
7715 }
7716}
7717
7718impl SseEncode for crate::model::BuyBitcoinProvider {
7719 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7721 <i32>::sse_encode(
7722 match self {
7723 crate::model::BuyBitcoinProvider::Moonpay => 0,
7724 _ => {
7725 unimplemented!("");
7726 }
7727 },
7728 serializer,
7729 );
7730 }
7731}
7732
7733impl SseEncode for crate::model::BuyBitcoinRequest {
7734 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7736 <crate::model::PrepareBuyBitcoinResponse>::sse_encode(self.prepare_response, serializer);
7737 <Option<String>>::sse_encode(self.redirect_url, serializer);
7738 }
7739}
7740
7741impl SseEncode for crate::model::CheckMessageRequest {
7742 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7744 <String>::sse_encode(self.message, serializer);
7745 <String>::sse_encode(self.pubkey, serializer);
7746 <String>::sse_encode(self.signature, serializer);
7747 }
7748}
7749
7750impl SseEncode for crate::model::CheckMessageResponse {
7751 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7753 <bool>::sse_encode(self.is_valid, serializer);
7754 }
7755}
7756
7757impl SseEncode for crate::model::Config {
7758 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7760 <crate::model::BlockchainExplorer>::sse_encode(self.liquid_explorer, serializer);
7761 <crate::model::BlockchainExplorer>::sse_encode(self.bitcoin_explorer, serializer);
7762 <String>::sse_encode(self.working_dir, serializer);
7763 <crate::model::LiquidNetwork>::sse_encode(self.network, serializer);
7764 <u64>::sse_encode(self.payment_timeout_sec, serializer);
7765 <Option<String>>::sse_encode(self.sync_service_url, serializer);
7766 <Option<u64>>::sse_encode(self.zero_conf_max_amount_sat, serializer);
7767 <Option<String>>::sse_encode(self.breez_api_key, serializer);
7768 <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_encode(
7769 self.external_input_parsers,
7770 serializer,
7771 );
7772 <bool>::sse_encode(self.use_default_external_input_parsers, serializer);
7773 <Option<u64>>::sse_encode(self.onchain_fee_rate_leeway_sat, serializer);
7774 <Option<Vec<crate::model::AssetMetadata>>>::sse_encode(self.asset_metadata, serializer);
7775 <Option<String>>::sse_encode(self.sideswap_api_key, serializer);
7776 }
7777}
7778
7779impl SseEncode for crate::model::ConnectRequest {
7780 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7782 <crate::model::Config>::sse_encode(self.config, serializer);
7783 <Option<String>>::sse_encode(self.mnemonic, serializer);
7784 <Option<String>>::sse_encode(self.passphrase, serializer);
7785 <Option<Vec<u8>>>::sse_encode(self.seed, serializer);
7786 }
7787}
7788
7789impl SseEncode for crate::model::CreateBolt12InvoiceRequest {
7790 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7792 <String>::sse_encode(self.offer, serializer);
7793 <String>::sse_encode(self.invoice_request, serializer);
7794 }
7795}
7796
7797impl SseEncode for crate::model::CreateBolt12InvoiceResponse {
7798 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7800 <String>::sse_encode(self.invoice, serializer);
7801 }
7802}
7803
7804impl SseEncode for crate::bindings::CurrencyInfo {
7805 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7807 <String>::sse_encode(self.name, serializer);
7808 <u32>::sse_encode(self.fraction_size, serializer);
7809 <Option<u32>>::sse_encode(self.spacing, serializer);
7810 <Option<crate::bindings::Symbol>>::sse_encode(self.symbol, serializer);
7811 <Option<crate::bindings::Symbol>>::sse_encode(self.uniq_symbol, serializer);
7812 <Vec<crate::bindings::LocalizedName>>::sse_encode(self.localized_name, serializer);
7813 <Vec<crate::bindings::LocaleOverrides>>::sse_encode(self.locale_overrides, serializer);
7814 }
7815}
7816
7817impl SseEncode for crate::bindings::ExternalInputParser {
7818 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7820 <String>::sse_encode(self.provider_id, serializer);
7821 <String>::sse_encode(self.input_regex, serializer);
7822 <String>::sse_encode(self.parser_url, serializer);
7823 }
7824}
7825
7826impl SseEncode for f64 {
7827 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7829 serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
7830 }
7831}
7832
7833impl SseEncode for crate::model::FetchPaymentProposedFeesRequest {
7834 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7836 <String>::sse_encode(self.swap_id, serializer);
7837 }
7838}
7839
7840impl SseEncode for crate::model::FetchPaymentProposedFeesResponse {
7841 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7843 <String>::sse_encode(self.swap_id, serializer);
7844 <u64>::sse_encode(self.fees_sat, serializer);
7845 <u64>::sse_encode(self.payer_amount_sat, serializer);
7846 <u64>::sse_encode(self.receiver_amount_sat, serializer);
7847 }
7848}
7849
7850impl SseEncode for crate::bindings::FiatCurrency {
7851 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7853 <String>::sse_encode(self.id, serializer);
7854 <crate::bindings::CurrencyInfo>::sse_encode(self.info, serializer);
7855 }
7856}
7857
7858impl SseEncode for crate::model::GetInfoResponse {
7859 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7861 <crate::model::WalletInfo>::sse_encode(self.wallet_info, serializer);
7862 <crate::model::BlockchainInfo>::sse_encode(self.blockchain_info, serializer);
7863 }
7864}
7865
7866impl SseEncode for crate::model::GetPaymentRequest {
7867 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7869 match self {
7870 crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
7871 <i32>::sse_encode(0, serializer);
7872 <String>::sse_encode(payment_hash, serializer);
7873 }
7874 crate::model::GetPaymentRequest::SwapId { swap_id } => {
7875 <i32>::sse_encode(1, serializer);
7876 <String>::sse_encode(swap_id, serializer);
7877 }
7878 _ => {
7879 unimplemented!("");
7880 }
7881 }
7882 }
7883}
7884
7885impl SseEncode for i32 {
7886 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7888 serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
7889 }
7890}
7891
7892impl SseEncode for i64 {
7893 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7895 serializer.cursor.write_i64::<NativeEndian>(self).unwrap();
7896 }
7897}
7898
7899impl SseEncode for crate::bindings::InputType {
7900 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7902 match self {
7903 crate::bindings::InputType::BitcoinAddress { address } => {
7904 <i32>::sse_encode(0, serializer);
7905 <crate::bindings::BitcoinAddressData>::sse_encode(address, serializer);
7906 }
7907 crate::bindings::InputType::LiquidAddress { address } => {
7908 <i32>::sse_encode(1, serializer);
7909 <crate::bindings::LiquidAddressData>::sse_encode(address, serializer);
7910 }
7911 crate::bindings::InputType::Bolt11 { invoice } => {
7912 <i32>::sse_encode(2, serializer);
7913 <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
7914 }
7915 crate::bindings::InputType::Bolt12Offer {
7916 offer,
7917 bip353_address,
7918 } => {
7919 <i32>::sse_encode(3, serializer);
7920 <crate::bindings::LNOffer>::sse_encode(offer, serializer);
7921 <Option<String>>::sse_encode(bip353_address, serializer);
7922 }
7923 crate::bindings::InputType::NodeId { node_id } => {
7924 <i32>::sse_encode(4, serializer);
7925 <String>::sse_encode(node_id, serializer);
7926 }
7927 crate::bindings::InputType::Url { url } => {
7928 <i32>::sse_encode(5, serializer);
7929 <String>::sse_encode(url, serializer);
7930 }
7931 crate::bindings::InputType::LnUrlPay {
7932 data,
7933 bip353_address,
7934 } => {
7935 <i32>::sse_encode(6, serializer);
7936 <crate::bindings::LnUrlPayRequestData>::sse_encode(data, serializer);
7937 <Option<String>>::sse_encode(bip353_address, serializer);
7938 }
7939 crate::bindings::InputType::LnUrlWithdraw { data } => {
7940 <i32>::sse_encode(7, serializer);
7941 <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(data, serializer);
7942 }
7943 crate::bindings::InputType::LnUrlAuth { data } => {
7944 <i32>::sse_encode(8, serializer);
7945 <crate::bindings::LnUrlAuthRequestData>::sse_encode(data, serializer);
7946 }
7947 crate::bindings::InputType::LnUrlError { data } => {
7948 <i32>::sse_encode(9, serializer);
7949 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
7950 }
7951 _ => {
7952 unimplemented!("");
7953 }
7954 }
7955 }
7956}
7957
7958impl SseEncode for crate::model::LightningPaymentLimitsResponse {
7959 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7961 <crate::model::Limits>::sse_encode(self.send, serializer);
7962 <crate::model::Limits>::sse_encode(self.receive, serializer);
7963 }
7964}
7965
7966impl SseEncode for crate::model::Limits {
7967 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7969 <u64>::sse_encode(self.min_sat, serializer);
7970 <u64>::sse_encode(self.max_sat, serializer);
7971 <u64>::sse_encode(self.max_zero_conf_sat, serializer);
7972 }
7973}
7974
7975impl SseEncode for crate::bindings::LiquidAddressData {
7976 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7978 <String>::sse_encode(self.address, serializer);
7979 <crate::bindings::Network>::sse_encode(self.network, serializer);
7980 <Option<String>>::sse_encode(self.asset_id, serializer);
7981 <Option<f64>>::sse_encode(self.amount, serializer);
7982 <Option<u64>>::sse_encode(self.amount_sat, serializer);
7983 <Option<String>>::sse_encode(self.label, serializer);
7984 <Option<String>>::sse_encode(self.message, serializer);
7985 }
7986}
7987
7988impl SseEncode for crate::model::LiquidNetwork {
7989 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7991 <i32>::sse_encode(
7992 match self {
7993 crate::model::LiquidNetwork::Mainnet => 0,
7994 crate::model::LiquidNetwork::Testnet => 1,
7995 crate::model::LiquidNetwork::Regtest => 2,
7996 _ => {
7997 unimplemented!("");
7998 }
7999 },
8000 serializer,
8001 );
8002 }
8003}
8004
8005impl SseEncode for Vec<String> {
8006 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8008 <i32>::sse_encode(self.len() as _, serializer);
8009 for item in self {
8010 <String>::sse_encode(item, serializer);
8011 }
8012 }
8013}
8014
8015impl SseEncode for Vec<crate::model::AssetBalance> {
8016 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8018 <i32>::sse_encode(self.len() as _, serializer);
8019 for item in self {
8020 <crate::model::AssetBalance>::sse_encode(item, serializer);
8021 }
8022 }
8023}
8024
8025impl SseEncode for Vec<crate::model::AssetMetadata> {
8026 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8028 <i32>::sse_encode(self.len() as _, serializer);
8029 for item in self {
8030 <crate::model::AssetMetadata>::sse_encode(item, serializer);
8031 }
8032 }
8033}
8034
8035impl SseEncode for Vec<crate::bindings::ExternalInputParser> {
8036 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8038 <i32>::sse_encode(self.len() as _, serializer);
8039 for item in self {
8040 <crate::bindings::ExternalInputParser>::sse_encode(item, serializer);
8041 }
8042 }
8043}
8044
8045impl SseEncode for Vec<crate::bindings::FiatCurrency> {
8046 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8048 <i32>::sse_encode(self.len() as _, serializer);
8049 for item in self {
8050 <crate::bindings::FiatCurrency>::sse_encode(item, serializer);
8051 }
8052 }
8053}
8054
8055impl SseEncode for Vec<crate::bindings::LnOfferBlindedPath> {
8056 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8058 <i32>::sse_encode(self.len() as _, serializer);
8059 for item in self {
8060 <crate::bindings::LnOfferBlindedPath>::sse_encode(item, serializer);
8061 }
8062 }
8063}
8064
8065impl SseEncode for Vec<crate::bindings::LocaleOverrides> {
8066 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8068 <i32>::sse_encode(self.len() as _, serializer);
8069 for item in self {
8070 <crate::bindings::LocaleOverrides>::sse_encode(item, serializer);
8071 }
8072 }
8073}
8074
8075impl SseEncode for Vec<crate::bindings::LocalizedName> {
8076 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8078 <i32>::sse_encode(self.len() as _, serializer);
8079 for item in self {
8080 <crate::bindings::LocalizedName>::sse_encode(item, serializer);
8081 }
8082 }
8083}
8084
8085impl SseEncode for Vec<crate::model::Payment> {
8086 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8088 <i32>::sse_encode(self.len() as _, serializer);
8089 for item in self {
8090 <crate::model::Payment>::sse_encode(item, serializer);
8091 }
8092 }
8093}
8094
8095impl SseEncode for crate::model::ListPaymentDetails {
8096 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8098 match self {
8099 crate::model::ListPaymentDetails::Liquid {
8100 asset_id,
8101 destination,
8102 } => {
8103 <i32>::sse_encode(0, serializer);
8104 <Option<String>>::sse_encode(asset_id, serializer);
8105 <Option<String>>::sse_encode(destination, serializer);
8106 }
8107 crate::model::ListPaymentDetails::Bitcoin { address } => {
8108 <i32>::sse_encode(1, serializer);
8109 <Option<String>>::sse_encode(address, serializer);
8110 }
8111 _ => {
8112 unimplemented!("");
8113 }
8114 }
8115 }
8116}
8117
8118impl SseEncode for Vec<crate::model::PaymentState> {
8119 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8121 <i32>::sse_encode(self.len() as _, serializer);
8122 for item in self {
8123 <crate::model::PaymentState>::sse_encode(item, serializer);
8124 }
8125 }
8126}
8127
8128impl SseEncode for Vec<crate::model::PaymentType> {
8129 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8131 <i32>::sse_encode(self.len() as _, serializer);
8132 for item in self {
8133 <crate::model::PaymentType>::sse_encode(item, serializer);
8134 }
8135 }
8136}
8137
8138impl SseEncode for crate::model::ListPaymentsRequest {
8139 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8141 <Option<Vec<crate::model::PaymentType>>>::sse_encode(self.filters, serializer);
8142 <Option<Vec<crate::model::PaymentState>>>::sse_encode(self.states, serializer);
8143 <Option<i64>>::sse_encode(self.from_timestamp, serializer);
8144 <Option<i64>>::sse_encode(self.to_timestamp, serializer);
8145 <Option<u32>>::sse_encode(self.offset, serializer);
8146 <Option<u32>>::sse_encode(self.limit, serializer);
8147 <Option<crate::model::ListPaymentDetails>>::sse_encode(self.details, serializer);
8148 <Option<bool>>::sse_encode(self.sort_ascending, serializer);
8149 }
8150}
8151
8152impl SseEncode for Vec<u8> {
8153 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8155 <i32>::sse_encode(self.len() as _, serializer);
8156 for item in self {
8157 <u8>::sse_encode(item, serializer);
8158 }
8159 }
8160}
8161
8162impl SseEncode for Vec<crate::bindings::Rate> {
8163 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8165 <i32>::sse_encode(self.len() as _, serializer);
8166 for item in self {
8167 <crate::bindings::Rate>::sse_encode(item, serializer);
8168 }
8169 }
8170}
8171
8172impl SseEncode for Vec<crate::model::RefundableSwap> {
8173 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8175 <i32>::sse_encode(self.len() as _, serializer);
8176 for item in self {
8177 <crate::model::RefundableSwap>::sse_encode(item, serializer);
8178 }
8179 }
8180}
8181
8182impl SseEncode for Vec<crate::bindings::RouteHint> {
8183 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8185 <i32>::sse_encode(self.len() as _, serializer);
8186 for item in self {
8187 <crate::bindings::RouteHint>::sse_encode(item, serializer);
8188 }
8189 }
8190}
8191
8192impl SseEncode for Vec<crate::bindings::RouteHintHop> {
8193 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8195 <i32>::sse_encode(self.len() as _, serializer);
8196 for item in self {
8197 <crate::bindings::RouteHintHop>::sse_encode(item, serializer);
8198 }
8199 }
8200}
8201
8202impl SseEncode for crate::bindings::LNInvoice {
8203 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8205 <String>::sse_encode(self.bolt11, serializer);
8206 <crate::bindings::Network>::sse_encode(self.network, serializer);
8207 <String>::sse_encode(self.payee_pubkey, serializer);
8208 <String>::sse_encode(self.payment_hash, serializer);
8209 <Option<String>>::sse_encode(self.description, serializer);
8210 <Option<String>>::sse_encode(self.description_hash, serializer);
8211 <Option<u64>>::sse_encode(self.amount_msat, serializer);
8212 <u64>::sse_encode(self.timestamp, serializer);
8213 <u64>::sse_encode(self.expiry, serializer);
8214 <Vec<crate::bindings::RouteHint>>::sse_encode(self.routing_hints, serializer);
8215 <Vec<u8>>::sse_encode(self.payment_secret, serializer);
8216 <u64>::sse_encode(self.min_final_cltv_expiry_delta, serializer);
8217 }
8218}
8219
8220impl SseEncode for crate::bindings::LNOffer {
8221 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8223 <String>::sse_encode(self.offer, serializer);
8224 <Vec<String>>::sse_encode(self.chains, serializer);
8225 <Option<crate::bindings::Amount>>::sse_encode(self.min_amount, serializer);
8226 <Option<String>>::sse_encode(self.description, serializer);
8227 <Option<u64>>::sse_encode(self.absolute_expiry, serializer);
8228 <Option<String>>::sse_encode(self.issuer, serializer);
8229 <Option<String>>::sse_encode(self.signing_pubkey, serializer);
8230 <Vec<crate::bindings::LnOfferBlindedPath>>::sse_encode(self.paths, serializer);
8231 }
8232}
8233
8234impl SseEncode for crate::bindings::LnOfferBlindedPath {
8235 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8237 <Vec<String>>::sse_encode(self.blinded_hops, serializer);
8238 }
8239}
8240
8241impl SseEncode for crate::bindings::duplicates::LnUrlAuthError {
8242 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8244 match self {
8245 crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
8246 <i32>::sse_encode(0, serializer);
8247 <String>::sse_encode(err, serializer);
8248 }
8249 crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
8250 <i32>::sse_encode(1, serializer);
8251 <String>::sse_encode(err, serializer);
8252 }
8253 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
8254 <i32>::sse_encode(2, serializer);
8255 <String>::sse_encode(err, serializer);
8256 }
8257 _ => {
8258 unimplemented!("");
8259 }
8260 }
8261 }
8262}
8263
8264impl SseEncode for crate::bindings::LnUrlAuthRequestData {
8265 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8267 <String>::sse_encode(self.k1, serializer);
8268 <Option<String>>::sse_encode(self.action, serializer);
8269 <String>::sse_encode(self.domain, serializer);
8270 <String>::sse_encode(self.url, serializer);
8271 }
8272}
8273
8274impl SseEncode for crate::bindings::duplicates::LnUrlCallbackStatus {
8275 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8277 match self {
8278 crate::bindings::duplicates::LnUrlCallbackStatus::Ok => {
8279 <i32>::sse_encode(0, serializer);
8280 }
8281 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
8282 <i32>::sse_encode(1, serializer);
8283 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8284 }
8285 _ => {
8286 unimplemented!("");
8287 }
8288 }
8289 }
8290}
8291
8292impl SseEncode for crate::bindings::LnUrlErrorData {
8293 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8295 <String>::sse_encode(self.reason, serializer);
8296 }
8297}
8298
8299impl SseEncode for crate::model::LnUrlInfo {
8300 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8302 <Option<String>>::sse_encode(self.ln_address, serializer);
8303 <Option<String>>::sse_encode(self.lnurl_pay_comment, serializer);
8304 <Option<String>>::sse_encode(self.lnurl_pay_domain, serializer);
8305 <Option<String>>::sse_encode(self.lnurl_pay_metadata, serializer);
8306 <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8307 self.lnurl_pay_success_action,
8308 serializer,
8309 );
8310 <Option<crate::bindings::SuccessAction>>::sse_encode(
8311 self.lnurl_pay_unprocessed_success_action,
8312 serializer,
8313 );
8314 <Option<String>>::sse_encode(self.lnurl_withdraw_endpoint, serializer);
8315 }
8316}
8317
8318impl SseEncode for crate::bindings::duplicates::LnUrlPayError {
8319 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8321 match self {
8322 crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => {
8323 <i32>::sse_encode(0, serializer);
8324 }
8325 crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
8326 <i32>::sse_encode(1, serializer);
8327 <String>::sse_encode(err, serializer);
8328 }
8329 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
8330 <i32>::sse_encode(2, serializer);
8331 <String>::sse_encode(err, serializer);
8332 }
8333 crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
8334 <i32>::sse_encode(3, serializer);
8335 <String>::sse_encode(err, serializer);
8336 }
8337 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
8338 <i32>::sse_encode(4, serializer);
8339 <String>::sse_encode(err, serializer);
8340 }
8341 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
8342 <i32>::sse_encode(5, serializer);
8343 <String>::sse_encode(err, serializer);
8344 }
8345 crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
8346 <i32>::sse_encode(6, serializer);
8347 <String>::sse_encode(err, serializer);
8348 }
8349 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
8350 <i32>::sse_encode(7, serializer);
8351 <String>::sse_encode(err, serializer);
8352 }
8353 crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
8354 <i32>::sse_encode(8, serializer);
8355 <String>::sse_encode(err, serializer);
8356 }
8357 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
8358 <i32>::sse_encode(9, serializer);
8359 <String>::sse_encode(err, serializer);
8360 }
8361 crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
8362 <i32>::sse_encode(10, serializer);
8363 <String>::sse_encode(err, serializer);
8364 }
8365 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
8366 <i32>::sse_encode(11, serializer);
8367 <String>::sse_encode(err, serializer);
8368 }
8369 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
8370 <i32>::sse_encode(12, serializer);
8371 <String>::sse_encode(err, serializer);
8372 }
8373 _ => {
8374 unimplemented!("");
8375 }
8376 }
8377 }
8378}
8379
8380impl SseEncode for crate::bindings::LnUrlPayErrorData {
8381 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8383 <String>::sse_encode(self.payment_hash, serializer);
8384 <String>::sse_encode(self.reason, serializer);
8385 }
8386}
8387
8388impl SseEncode for crate::model::LnUrlPayRequest {
8389 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8391 <crate::model::PrepareLnUrlPayResponse>::sse_encode(self.prepare_response, serializer);
8392 }
8393}
8394
8395impl SseEncode for crate::bindings::LnUrlPayRequestData {
8396 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8398 <String>::sse_encode(self.callback, serializer);
8399 <u64>::sse_encode(self.min_sendable, serializer);
8400 <u64>::sse_encode(self.max_sendable, serializer);
8401 <String>::sse_encode(self.metadata_str, serializer);
8402 <u16>::sse_encode(self.comment_allowed, serializer);
8403 <String>::sse_encode(self.domain, serializer);
8404 <bool>::sse_encode(self.allows_nostr, serializer);
8405 <Option<String>>::sse_encode(self.nostr_pubkey, serializer);
8406 <Option<String>>::sse_encode(self.ln_address, serializer);
8407 }
8408}
8409
8410impl SseEncode for crate::model::LnUrlPayResult {
8411 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8413 match self {
8414 crate::model::LnUrlPayResult::EndpointSuccess { data } => {
8415 <i32>::sse_encode(0, serializer);
8416 <crate::model::LnUrlPaySuccessData>::sse_encode(data, serializer);
8417 }
8418 crate::model::LnUrlPayResult::EndpointError { data } => {
8419 <i32>::sse_encode(1, serializer);
8420 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8421 }
8422 crate::model::LnUrlPayResult::PayError { data } => {
8423 <i32>::sse_encode(2, serializer);
8424 <crate::bindings::LnUrlPayErrorData>::sse_encode(data, serializer);
8425 }
8426 _ => {
8427 unimplemented!("");
8428 }
8429 }
8430 }
8431}
8432
8433impl SseEncode for crate::model::LnUrlPaySuccessData {
8434 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8436 <crate::model::Payment>::sse_encode(self.payment, serializer);
8437 <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8438 self.success_action,
8439 serializer,
8440 );
8441 }
8442}
8443
8444impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawError {
8445 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8447 match self {
8448 crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
8449 <i32>::sse_encode(0, serializer);
8450 <String>::sse_encode(err, serializer);
8451 }
8452 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
8453 <i32>::sse_encode(1, serializer);
8454 <String>::sse_encode(err, serializer);
8455 }
8456 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
8457 <i32>::sse_encode(2, serializer);
8458 <String>::sse_encode(err, serializer);
8459 }
8460 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
8461 <i32>::sse_encode(3, serializer);
8462 <String>::sse_encode(err, serializer);
8463 }
8464 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
8465 <i32>::sse_encode(4, serializer);
8466 <String>::sse_encode(err, serializer);
8467 }
8468 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
8469 <i32>::sse_encode(5, serializer);
8470 <String>::sse_encode(err, serializer);
8471 }
8472 _ => {
8473 unimplemented!("");
8474 }
8475 }
8476 }
8477}
8478
8479impl SseEncode for crate::bindings::LnUrlWithdrawRequest {
8480 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8482 <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(self.data, serializer);
8483 <u64>::sse_encode(self.amount_msat, serializer);
8484 <Option<String>>::sse_encode(self.description, serializer);
8485 }
8486}
8487
8488impl SseEncode for crate::bindings::LnUrlWithdrawRequestData {
8489 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8491 <String>::sse_encode(self.callback, serializer);
8492 <String>::sse_encode(self.k1, serializer);
8493 <String>::sse_encode(self.default_description, serializer);
8494 <u64>::sse_encode(self.min_withdrawable, serializer);
8495 <u64>::sse_encode(self.max_withdrawable, serializer);
8496 }
8497}
8498
8499impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawResult {
8500 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8502 match self {
8503 crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
8504 <i32>::sse_encode(0, serializer);
8505 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8506 data, serializer,
8507 );
8508 }
8509 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
8510 <i32>::sse_encode(1, serializer);
8511 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8512 data, serializer,
8513 );
8514 }
8515 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
8516 <i32>::sse_encode(2, serializer);
8517 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8518 }
8519 _ => {
8520 unimplemented!("");
8521 }
8522 }
8523 }
8524}
8525
8526impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
8527 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8529 <crate::bindings::LNInvoice>::sse_encode(self.invoice, serializer);
8530 }
8531}
8532
8533impl SseEncode for crate::bindings::LocaleOverrides {
8534 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8536 <String>::sse_encode(self.locale, serializer);
8537 <Option<u32>>::sse_encode(self.spacing, serializer);
8538 <crate::bindings::Symbol>::sse_encode(self.symbol, serializer);
8539 }
8540}
8541
8542impl SseEncode for crate::bindings::LocalizedName {
8543 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8545 <String>::sse_encode(self.locale, serializer);
8546 <String>::sse_encode(self.name, serializer);
8547 }
8548}
8549
8550impl SseEncode for crate::model::LogEntry {
8551 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8553 <String>::sse_encode(self.line, serializer);
8554 <String>::sse_encode(self.level, serializer);
8555 }
8556}
8557
8558impl SseEncode for crate::bindings::MessageSuccessActionData {
8559 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8561 <String>::sse_encode(self.message, serializer);
8562 }
8563}
8564
8565impl SseEncode for crate::bindings::Network {
8566 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8568 <i32>::sse_encode(
8569 match self {
8570 crate::bindings::Network::Bitcoin => 0,
8571 crate::bindings::Network::Testnet => 1,
8572 crate::bindings::Network::Signet => 2,
8573 crate::bindings::Network::Regtest => 3,
8574 _ => {
8575 unimplemented!("");
8576 }
8577 },
8578 serializer,
8579 );
8580 }
8581}
8582
8583impl SseEncode for crate::model::OnchainPaymentLimitsResponse {
8584 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8586 <crate::model::Limits>::sse_encode(self.send, serializer);
8587 <crate::model::Limits>::sse_encode(self.receive, serializer);
8588 }
8589}
8590
8591impl SseEncode for Option<String> {
8592 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8594 <bool>::sse_encode(self.is_some(), serializer);
8595 if let Some(value) = self {
8596 <String>::sse_encode(value, serializer);
8597 }
8598 }
8599}
8600
8601impl SseEncode for Option<crate::bindings::Amount> {
8602 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8604 <bool>::sse_encode(self.is_some(), serializer);
8605 if let Some(value) = self {
8606 <crate::bindings::Amount>::sse_encode(value, serializer);
8607 }
8608 }
8609}
8610
8611impl SseEncode for Option<crate::model::AssetInfo> {
8612 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8614 <bool>::sse_encode(self.is_some(), serializer);
8615 if let Some(value) = self {
8616 <crate::model::AssetInfo>::sse_encode(value, serializer);
8617 }
8618 }
8619}
8620
8621impl SseEncode for Option<bool> {
8622 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8624 <bool>::sse_encode(self.is_some(), serializer);
8625 if let Some(value) = self {
8626 <bool>::sse_encode(value, serializer);
8627 }
8628 }
8629}
8630
8631impl SseEncode for Option<f64> {
8632 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8634 <bool>::sse_encode(self.is_some(), serializer);
8635 if let Some(value) = self {
8636 <f64>::sse_encode(value, serializer);
8637 }
8638 }
8639}
8640
8641impl SseEncode for Option<i64> {
8642 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8644 <bool>::sse_encode(self.is_some(), serializer);
8645 if let Some(value) = self {
8646 <i64>::sse_encode(value, serializer);
8647 }
8648 }
8649}
8650
8651impl SseEncode for Option<crate::model::ListPaymentDetails> {
8652 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8654 <bool>::sse_encode(self.is_some(), serializer);
8655 if let Some(value) = self {
8656 <crate::model::ListPaymentDetails>::sse_encode(value, serializer);
8657 }
8658 }
8659}
8660
8661impl SseEncode for Option<crate::model::LnUrlInfo> {
8662 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8664 <bool>::sse_encode(self.is_some(), serializer);
8665 if let Some(value) = self {
8666 <crate::model::LnUrlInfo>::sse_encode(value, serializer);
8667 }
8668 }
8669}
8670
8671impl SseEncode for Option<crate::model::PayAmount> {
8672 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8674 <bool>::sse_encode(self.is_some(), serializer);
8675 if let Some(value) = self {
8676 <crate::model::PayAmount>::sse_encode(value, serializer);
8677 }
8678 }
8679}
8680
8681impl SseEncode for Option<crate::model::Payment> {
8682 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8684 <bool>::sse_encode(self.is_some(), serializer);
8685 if let Some(value) = self {
8686 <crate::model::Payment>::sse_encode(value, serializer);
8687 }
8688 }
8689}
8690
8691impl SseEncode for Option<crate::model::ReceiveAmount> {
8692 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8694 <bool>::sse_encode(self.is_some(), serializer);
8695 if let Some(value) = self {
8696 <crate::model::ReceiveAmount>::sse_encode(value, serializer);
8697 }
8698 }
8699}
8700
8701impl SseEncode for Option<crate::bindings::SuccessAction> {
8702 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8704 <bool>::sse_encode(self.is_some(), serializer);
8705 if let Some(value) = self {
8706 <crate::bindings::SuccessAction>::sse_encode(value, serializer);
8707 }
8708 }
8709}
8710
8711impl SseEncode for Option<crate::bindings::SuccessActionProcessed> {
8712 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8714 <bool>::sse_encode(self.is_some(), serializer);
8715 if let Some(value) = self {
8716 <crate::bindings::SuccessActionProcessed>::sse_encode(value, serializer);
8717 }
8718 }
8719}
8720
8721impl SseEncode for Option<crate::bindings::Symbol> {
8722 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8724 <bool>::sse_encode(self.is_some(), serializer);
8725 if let Some(value) = self {
8726 <crate::bindings::Symbol>::sse_encode(value, serializer);
8727 }
8728 }
8729}
8730
8731impl SseEncode for Option<u32> {
8732 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8734 <bool>::sse_encode(self.is_some(), serializer);
8735 if let Some(value) = self {
8736 <u32>::sse_encode(value, serializer);
8737 }
8738 }
8739}
8740
8741impl SseEncode for Option<u64> {
8742 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8744 <bool>::sse_encode(self.is_some(), serializer);
8745 if let Some(value) = self {
8746 <u64>::sse_encode(value, serializer);
8747 }
8748 }
8749}
8750
8751impl SseEncode for Option<Vec<crate::model::AssetMetadata>> {
8752 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8754 <bool>::sse_encode(self.is_some(), serializer);
8755 if let Some(value) = self {
8756 <Vec<crate::model::AssetMetadata>>::sse_encode(value, serializer);
8757 }
8758 }
8759}
8760
8761impl SseEncode for Option<Vec<crate::bindings::ExternalInputParser>> {
8762 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8764 <bool>::sse_encode(self.is_some(), serializer);
8765 if let Some(value) = self {
8766 <Vec<crate::bindings::ExternalInputParser>>::sse_encode(value, serializer);
8767 }
8768 }
8769}
8770
8771impl SseEncode for Option<Vec<crate::model::PaymentState>> {
8772 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8774 <bool>::sse_encode(self.is_some(), serializer);
8775 if let Some(value) = self {
8776 <Vec<crate::model::PaymentState>>::sse_encode(value, serializer);
8777 }
8778 }
8779}
8780
8781impl SseEncode for Option<Vec<crate::model::PaymentType>> {
8782 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8784 <bool>::sse_encode(self.is_some(), serializer);
8785 if let Some(value) = self {
8786 <Vec<crate::model::PaymentType>>::sse_encode(value, serializer);
8787 }
8788 }
8789}
8790
8791impl SseEncode for Option<Vec<u8>> {
8792 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8794 <bool>::sse_encode(self.is_some(), serializer);
8795 if let Some(value) = self {
8796 <Vec<u8>>::sse_encode(value, serializer);
8797 }
8798 }
8799}
8800
8801impl SseEncode for crate::model::PayAmount {
8802 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8804 match self {
8805 crate::model::PayAmount::Bitcoin {
8806 receiver_amount_sat,
8807 } => {
8808 <i32>::sse_encode(0, serializer);
8809 <u64>::sse_encode(receiver_amount_sat, serializer);
8810 }
8811 crate::model::PayAmount::Asset {
8812 asset_id,
8813 receiver_amount,
8814 estimate_asset_fees,
8815 pay_with_bitcoin,
8816 } => {
8817 <i32>::sse_encode(1, serializer);
8818 <String>::sse_encode(asset_id, serializer);
8819 <f64>::sse_encode(receiver_amount, serializer);
8820 <Option<bool>>::sse_encode(estimate_asset_fees, serializer);
8821 <Option<bool>>::sse_encode(pay_with_bitcoin, serializer);
8822 }
8823 crate::model::PayAmount::Drain => {
8824 <i32>::sse_encode(2, serializer);
8825 }
8826 _ => {
8827 unimplemented!("");
8828 }
8829 }
8830 }
8831}
8832
8833impl SseEncode for crate::model::PayOnchainRequest {
8834 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8836 <String>::sse_encode(self.address, serializer);
8837 <crate::model::PreparePayOnchainResponse>::sse_encode(self.prepare_response, serializer);
8838 }
8839}
8840
8841impl SseEncode for crate::model::Payment {
8842 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8844 <Option<String>>::sse_encode(self.destination, serializer);
8845 <Option<String>>::sse_encode(self.tx_id, serializer);
8846 <Option<String>>::sse_encode(self.unblinding_data, serializer);
8847 <u32>::sse_encode(self.timestamp, serializer);
8848 <u64>::sse_encode(self.amount_sat, serializer);
8849 <u64>::sse_encode(self.fees_sat, serializer);
8850 <Option<u64>>::sse_encode(self.swapper_fees_sat, serializer);
8851 <crate::model::PaymentType>::sse_encode(self.payment_type, serializer);
8852 <crate::model::PaymentState>::sse_encode(self.status, serializer);
8853 <crate::model::PaymentDetails>::sse_encode(self.details, serializer);
8854 }
8855}
8856
8857impl SseEncode for crate::model::PaymentDetails {
8858 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8860 match self {
8861 crate::model::PaymentDetails::Lightning {
8862 swap_id,
8863 description,
8864 liquid_expiration_blockheight,
8865 preimage,
8866 invoice,
8867 bolt12_offer,
8868 payment_hash,
8869 destination_pubkey,
8870 lnurl_info,
8871 bip353_address,
8872 payer_note,
8873 claim_tx_id,
8874 refund_tx_id,
8875 refund_tx_amount_sat,
8876 } => {
8877 <i32>::sse_encode(0, serializer);
8878 <String>::sse_encode(swap_id, serializer);
8879 <String>::sse_encode(description, serializer);
8880 <u32>::sse_encode(liquid_expiration_blockheight, serializer);
8881 <Option<String>>::sse_encode(preimage, serializer);
8882 <Option<String>>::sse_encode(invoice, serializer);
8883 <Option<String>>::sse_encode(bolt12_offer, serializer);
8884 <Option<String>>::sse_encode(payment_hash, serializer);
8885 <Option<String>>::sse_encode(destination_pubkey, serializer);
8886 <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8887 <Option<String>>::sse_encode(bip353_address, serializer);
8888 <Option<String>>::sse_encode(payer_note, serializer);
8889 <Option<String>>::sse_encode(claim_tx_id, serializer);
8890 <Option<String>>::sse_encode(refund_tx_id, serializer);
8891 <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8892 }
8893 crate::model::PaymentDetails::Liquid {
8894 destination,
8895 description,
8896 asset_id,
8897 asset_info,
8898 lnurl_info,
8899 bip353_address,
8900 payer_note,
8901 } => {
8902 <i32>::sse_encode(1, serializer);
8903 <String>::sse_encode(destination, serializer);
8904 <String>::sse_encode(description, serializer);
8905 <String>::sse_encode(asset_id, serializer);
8906 <Option<crate::model::AssetInfo>>::sse_encode(asset_info, serializer);
8907 <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8908 <Option<String>>::sse_encode(bip353_address, serializer);
8909 <Option<String>>::sse_encode(payer_note, serializer);
8910 }
8911 crate::model::PaymentDetails::Bitcoin {
8912 swap_id,
8913 bitcoin_address,
8914 description,
8915 auto_accepted_fees,
8916 liquid_expiration_blockheight,
8917 bitcoin_expiration_blockheight,
8918 lockup_tx_id,
8919 claim_tx_id,
8920 refund_tx_id,
8921 refund_tx_amount_sat,
8922 } => {
8923 <i32>::sse_encode(2, serializer);
8924 <String>::sse_encode(swap_id, serializer);
8925 <String>::sse_encode(bitcoin_address, serializer);
8926 <String>::sse_encode(description, serializer);
8927 <bool>::sse_encode(auto_accepted_fees, serializer);
8928 <Option<u32>>::sse_encode(liquid_expiration_blockheight, serializer);
8929 <Option<u32>>::sse_encode(bitcoin_expiration_blockheight, serializer);
8930 <Option<String>>::sse_encode(lockup_tx_id, serializer);
8931 <Option<String>>::sse_encode(claim_tx_id, serializer);
8932 <Option<String>>::sse_encode(refund_tx_id, serializer);
8933 <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8934 }
8935 _ => {
8936 unimplemented!("");
8937 }
8938 }
8939 }
8940}
8941
8942impl SseEncode for crate::error::PaymentError {
8943 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8945 match self {
8946 crate::error::PaymentError::AlreadyClaimed => {
8947 <i32>::sse_encode(0, serializer);
8948 }
8949 crate::error::PaymentError::AlreadyPaid => {
8950 <i32>::sse_encode(1, serializer);
8951 }
8952 crate::error::PaymentError::PaymentInProgress => {
8953 <i32>::sse_encode(2, serializer);
8954 }
8955 crate::error::PaymentError::AmountOutOfRange { min, max } => {
8956 <i32>::sse_encode(3, serializer);
8957 <u64>::sse_encode(min, serializer);
8958 <u64>::sse_encode(max, serializer);
8959 }
8960 crate::error::PaymentError::AmountMissing { err } => {
8961 <i32>::sse_encode(4, serializer);
8962 <String>::sse_encode(err, serializer);
8963 }
8964 crate::error::PaymentError::AssetError { err } => {
8965 <i32>::sse_encode(5, serializer);
8966 <String>::sse_encode(err, serializer);
8967 }
8968 crate::error::PaymentError::InvalidNetwork { err } => {
8969 <i32>::sse_encode(6, serializer);
8970 <String>::sse_encode(err, serializer);
8971 }
8972 crate::error::PaymentError::Generic { err } => {
8973 <i32>::sse_encode(7, serializer);
8974 <String>::sse_encode(err, serializer);
8975 }
8976 crate::error::PaymentError::InvalidOrExpiredFees => {
8977 <i32>::sse_encode(8, serializer);
8978 }
8979 crate::error::PaymentError::InsufficientFunds => {
8980 <i32>::sse_encode(9, serializer);
8981 }
8982 crate::error::PaymentError::InvalidDescription { err } => {
8983 <i32>::sse_encode(10, serializer);
8984 <String>::sse_encode(err, serializer);
8985 }
8986 crate::error::PaymentError::InvalidInvoice { err } => {
8987 <i32>::sse_encode(11, serializer);
8988 <String>::sse_encode(err, serializer);
8989 }
8990 crate::error::PaymentError::InvalidPreimage => {
8991 <i32>::sse_encode(12, serializer);
8992 }
8993 crate::error::PaymentError::PairsNotFound => {
8994 <i32>::sse_encode(13, serializer);
8995 }
8996 crate::error::PaymentError::PaymentTimeout => {
8997 <i32>::sse_encode(14, serializer);
8998 }
8999 crate::error::PaymentError::PersistError => {
9000 <i32>::sse_encode(15, serializer);
9001 }
9002 crate::error::PaymentError::ReceiveError { err } => {
9003 <i32>::sse_encode(16, serializer);
9004 <String>::sse_encode(err, serializer);
9005 }
9006 crate::error::PaymentError::Refunded { err, refund_tx_id } => {
9007 <i32>::sse_encode(17, serializer);
9008 <String>::sse_encode(err, serializer);
9009 <String>::sse_encode(refund_tx_id, serializer);
9010 }
9011 crate::error::PaymentError::SelfTransferNotSupported => {
9012 <i32>::sse_encode(18, serializer);
9013 }
9014 crate::error::PaymentError::SendError { err } => {
9015 <i32>::sse_encode(19, serializer);
9016 <String>::sse_encode(err, serializer);
9017 }
9018 crate::error::PaymentError::SignerError { err } => {
9019 <i32>::sse_encode(20, serializer);
9020 <String>::sse_encode(err, serializer);
9021 }
9022 _ => {
9023 unimplemented!("");
9024 }
9025 }
9026 }
9027}
9028
9029impl SseEncode for crate::model::PaymentMethod {
9030 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9032 <i32>::sse_encode(
9033 match self {
9034 crate::model::PaymentMethod::Lightning => 0,
9035 crate::model::PaymentMethod::Bolt11Invoice => 1,
9036 crate::model::PaymentMethod::Bolt12Offer => 2,
9037 crate::model::PaymentMethod::BitcoinAddress => 3,
9038 crate::model::PaymentMethod::LiquidAddress => 4,
9039 _ => {
9040 unimplemented!("");
9041 }
9042 },
9043 serializer,
9044 );
9045 }
9046}
9047
9048impl SseEncode for crate::model::PaymentState {
9049 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9051 <i32>::sse_encode(
9052 match self {
9053 crate::model::PaymentState::Created => 0,
9054 crate::model::PaymentState::Pending => 1,
9055 crate::model::PaymentState::Complete => 2,
9056 crate::model::PaymentState::Failed => 3,
9057 crate::model::PaymentState::TimedOut => 4,
9058 crate::model::PaymentState::Refundable => 5,
9059 crate::model::PaymentState::RefundPending => 6,
9060 crate::model::PaymentState::WaitingFeeAcceptance => 7,
9061 _ => {
9062 unimplemented!("");
9063 }
9064 },
9065 serializer,
9066 );
9067 }
9068}
9069
9070impl SseEncode for crate::model::PaymentType {
9071 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9073 <i32>::sse_encode(
9074 match self {
9075 crate::model::PaymentType::Receive => 0,
9076 crate::model::PaymentType::Send => 1,
9077 _ => {
9078 unimplemented!("");
9079 }
9080 },
9081 serializer,
9082 );
9083 }
9084}
9085
9086impl SseEncode for crate::model::PrepareBuyBitcoinRequest {
9087 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9089 <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9090 <u64>::sse_encode(self.amount_sat, serializer);
9091 }
9092}
9093
9094impl SseEncode for crate::model::PrepareBuyBitcoinResponse {
9095 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9097 <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9098 <u64>::sse_encode(self.amount_sat, serializer);
9099 <u64>::sse_encode(self.fees_sat, serializer);
9100 }
9101}
9102
9103impl SseEncode for crate::model::PrepareLnUrlPayRequest {
9104 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9106 <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9107 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9108 <Option<String>>::sse_encode(self.bip353_address, serializer);
9109 <Option<String>>::sse_encode(self.comment, serializer);
9110 <Option<bool>>::sse_encode(self.validate_success_action_url, serializer);
9111 }
9112}
9113
9114impl SseEncode for crate::model::PrepareLnUrlPayResponse {
9115 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9117 <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9118 <u64>::sse_encode(self.fees_sat, serializer);
9119 <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9120 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9121 <Option<String>>::sse_encode(self.comment, serializer);
9122 <Option<crate::bindings::SuccessAction>>::sse_encode(self.success_action, serializer);
9123 }
9124}
9125
9126impl SseEncode for crate::model::PreparePayOnchainRequest {
9127 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9129 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9130 <Option<u32>>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9131 }
9132}
9133
9134impl SseEncode for crate::model::PreparePayOnchainResponse {
9135 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9137 <u64>::sse_encode(self.receiver_amount_sat, serializer);
9138 <u64>::sse_encode(self.claim_fees_sat, serializer);
9139 <u64>::sse_encode(self.total_fees_sat, serializer);
9140 }
9141}
9142
9143impl SseEncode for crate::model::PrepareReceiveRequest {
9144 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9146 <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9147 <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9148 }
9149}
9150
9151impl SseEncode for crate::model::PrepareReceiveResponse {
9152 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9154 <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9155 <u64>::sse_encode(self.fees_sat, serializer);
9156 <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9157 <Option<u64>>::sse_encode(self.min_payer_amount_sat, serializer);
9158 <Option<u64>>::sse_encode(self.max_payer_amount_sat, serializer);
9159 <Option<f64>>::sse_encode(self.swapper_feerate, serializer);
9160 }
9161}
9162
9163impl SseEncode for crate::model::PrepareRefundRequest {
9164 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9166 <String>::sse_encode(self.swap_address, serializer);
9167 <String>::sse_encode(self.refund_address, serializer);
9168 <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9169 }
9170}
9171
9172impl SseEncode for crate::model::PrepareRefundResponse {
9173 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9175 <u32>::sse_encode(self.tx_vsize, serializer);
9176 <u64>::sse_encode(self.tx_fee_sat, serializer);
9177 <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9178 }
9179}
9180
9181impl SseEncode for crate::model::PrepareSendRequest {
9182 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9184 <String>::sse_encode(self.destination, serializer);
9185 <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9186 }
9187}
9188
9189impl SseEncode for crate::model::PrepareSendResponse {
9190 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9192 <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9193 <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9194 <Option<u64>>::sse_encode(self.fees_sat, serializer);
9195 <Option<f64>>::sse_encode(self.estimated_asset_fees, serializer);
9196 }
9197}
9198
9199impl SseEncode for crate::bindings::Rate {
9200 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9202 <String>::sse_encode(self.coin, serializer);
9203 <f64>::sse_encode(self.value, serializer);
9204 }
9205}
9206
9207impl SseEncode for crate::model::ReceiveAmount {
9208 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9210 match self {
9211 crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
9212 <i32>::sse_encode(0, serializer);
9213 <u64>::sse_encode(payer_amount_sat, serializer);
9214 }
9215 crate::model::ReceiveAmount::Asset {
9216 asset_id,
9217 payer_amount,
9218 } => {
9219 <i32>::sse_encode(1, serializer);
9220 <String>::sse_encode(asset_id, serializer);
9221 <Option<f64>>::sse_encode(payer_amount, serializer);
9222 }
9223 _ => {
9224 unimplemented!("");
9225 }
9226 }
9227 }
9228}
9229
9230impl SseEncode for crate::model::ReceivePaymentRequest {
9231 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9233 <crate::model::PrepareReceiveResponse>::sse_encode(self.prepare_response, serializer);
9234 <Option<String>>::sse_encode(self.description, serializer);
9235 <Option<bool>>::sse_encode(self.use_description_hash, serializer);
9236 <Option<String>>::sse_encode(self.payer_note, serializer);
9237 }
9238}
9239
9240impl SseEncode for crate::model::ReceivePaymentResponse {
9241 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9243 <String>::sse_encode(self.destination, serializer);
9244 }
9245}
9246
9247impl SseEncode for crate::model::RecommendedFees {
9248 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9250 <u64>::sse_encode(self.fastest_fee, serializer);
9251 <u64>::sse_encode(self.half_hour_fee, serializer);
9252 <u64>::sse_encode(self.hour_fee, serializer);
9253 <u64>::sse_encode(self.economy_fee, serializer);
9254 <u64>::sse_encode(self.minimum_fee, serializer);
9255 }
9256}
9257
9258impl SseEncode for crate::model::RefundRequest {
9259 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9261 <String>::sse_encode(self.swap_address, serializer);
9262 <String>::sse_encode(self.refund_address, serializer);
9263 <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9264 }
9265}
9266
9267impl SseEncode for crate::model::RefundResponse {
9268 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9270 <String>::sse_encode(self.refund_tx_id, serializer);
9271 }
9272}
9273
9274impl SseEncode for crate::model::RefundableSwap {
9275 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9277 <String>::sse_encode(self.swap_address, serializer);
9278 <u32>::sse_encode(self.timestamp, serializer);
9279 <u64>::sse_encode(self.amount_sat, serializer);
9280 <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9281 }
9282}
9283
9284impl SseEncode for crate::model::RestoreRequest {
9285 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9287 <Option<String>>::sse_encode(self.backup_path, serializer);
9288 }
9289}
9290
9291impl SseEncode for crate::bindings::RouteHint {
9292 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9294 <Vec<crate::bindings::RouteHintHop>>::sse_encode(self.hops, serializer);
9295 }
9296}
9297
9298impl SseEncode for crate::bindings::RouteHintHop {
9299 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9301 <String>::sse_encode(self.src_node_id, serializer);
9302 <String>::sse_encode(self.short_channel_id, serializer);
9303 <u32>::sse_encode(self.fees_base_msat, serializer);
9304 <u32>::sse_encode(self.fees_proportional_millionths, serializer);
9305 <u64>::sse_encode(self.cltv_expiry_delta, serializer);
9306 <Option<u64>>::sse_encode(self.htlc_minimum_msat, serializer);
9307 <Option<u64>>::sse_encode(self.htlc_maximum_msat, serializer);
9308 }
9309}
9310
9311impl SseEncode for crate::error::SdkError {
9312 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9314 match self {
9315 crate::error::SdkError::AlreadyStarted => {
9316 <i32>::sse_encode(0, serializer);
9317 }
9318 crate::error::SdkError::Generic { err } => {
9319 <i32>::sse_encode(1, serializer);
9320 <String>::sse_encode(err, serializer);
9321 }
9322 crate::error::SdkError::NotStarted => {
9323 <i32>::sse_encode(2, serializer);
9324 }
9325 crate::error::SdkError::ServiceConnectivity { err } => {
9326 <i32>::sse_encode(3, serializer);
9327 <String>::sse_encode(err, serializer);
9328 }
9329 _ => {
9330 unimplemented!("");
9331 }
9332 }
9333 }
9334}
9335
9336impl SseEncode for crate::model::SdkEvent {
9337 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9339 match self {
9340 crate::model::SdkEvent::PaymentFailed { details } => {
9341 <i32>::sse_encode(0, serializer);
9342 <crate::model::Payment>::sse_encode(details, serializer);
9343 }
9344 crate::model::SdkEvent::PaymentPending { details } => {
9345 <i32>::sse_encode(1, serializer);
9346 <crate::model::Payment>::sse_encode(details, serializer);
9347 }
9348 crate::model::SdkEvent::PaymentRefundable { details } => {
9349 <i32>::sse_encode(2, serializer);
9350 <crate::model::Payment>::sse_encode(details, serializer);
9351 }
9352 crate::model::SdkEvent::PaymentRefunded { details } => {
9353 <i32>::sse_encode(3, serializer);
9354 <crate::model::Payment>::sse_encode(details, serializer);
9355 }
9356 crate::model::SdkEvent::PaymentRefundPending { details } => {
9357 <i32>::sse_encode(4, serializer);
9358 <crate::model::Payment>::sse_encode(details, serializer);
9359 }
9360 crate::model::SdkEvent::PaymentSucceeded { details } => {
9361 <i32>::sse_encode(5, serializer);
9362 <crate::model::Payment>::sse_encode(details, serializer);
9363 }
9364 crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
9365 <i32>::sse_encode(6, serializer);
9366 <crate::model::Payment>::sse_encode(details, serializer);
9367 }
9368 crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
9369 <i32>::sse_encode(7, serializer);
9370 <crate::model::Payment>::sse_encode(details, serializer);
9371 }
9372 crate::model::SdkEvent::Synced => {
9373 <i32>::sse_encode(8, serializer);
9374 }
9375 crate::model::SdkEvent::DataSynced {
9376 did_pull_new_records,
9377 } => {
9378 <i32>::sse_encode(9, serializer);
9379 <bool>::sse_encode(did_pull_new_records, serializer);
9380 }
9381 _ => {
9382 unimplemented!("");
9383 }
9384 }
9385 }
9386}
9387
9388impl SseEncode for crate::model::SendDestination {
9389 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9391 match self {
9392 crate::model::SendDestination::LiquidAddress {
9393 address_data,
9394 bip353_address,
9395 } => {
9396 <i32>::sse_encode(0, serializer);
9397 <crate::bindings::LiquidAddressData>::sse_encode(address_data, serializer);
9398 <Option<String>>::sse_encode(bip353_address, serializer);
9399 }
9400 crate::model::SendDestination::Bolt11 {
9401 invoice,
9402 bip353_address,
9403 } => {
9404 <i32>::sse_encode(1, serializer);
9405 <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
9406 <Option<String>>::sse_encode(bip353_address, serializer);
9407 }
9408 crate::model::SendDestination::Bolt12 {
9409 offer,
9410 receiver_amount_sat,
9411 bip353_address,
9412 } => {
9413 <i32>::sse_encode(2, serializer);
9414 <crate::bindings::LNOffer>::sse_encode(offer, serializer);
9415 <u64>::sse_encode(receiver_amount_sat, serializer);
9416 <Option<String>>::sse_encode(bip353_address, serializer);
9417 }
9418 _ => {
9419 unimplemented!("");
9420 }
9421 }
9422 }
9423}
9424
9425impl SseEncode for crate::model::SendPaymentRequest {
9426 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9428 <crate::model::PrepareSendResponse>::sse_encode(self.prepare_response, serializer);
9429 <Option<bool>>::sse_encode(self.use_asset_fees, serializer);
9430 <Option<String>>::sse_encode(self.payer_note, serializer);
9431 }
9432}
9433
9434impl SseEncode for crate::model::SendPaymentResponse {
9435 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9437 <crate::model::Payment>::sse_encode(self.payment, serializer);
9438 }
9439}
9440
9441impl SseEncode for crate::model::SignMessageRequest {
9442 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9444 <String>::sse_encode(self.message, serializer);
9445 }
9446}
9447
9448impl SseEncode for crate::model::SignMessageResponse {
9449 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9451 <String>::sse_encode(self.signature, serializer);
9452 }
9453}
9454
9455impl SseEncode for crate::bindings::SuccessAction {
9456 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9458 match self {
9459 crate::bindings::SuccessAction::Aes { data } => {
9460 <i32>::sse_encode(0, serializer);
9461 <crate::bindings::AesSuccessActionData>::sse_encode(data, serializer);
9462 }
9463 crate::bindings::SuccessAction::Message { data } => {
9464 <i32>::sse_encode(1, serializer);
9465 <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9466 }
9467 crate::bindings::SuccessAction::Url { data } => {
9468 <i32>::sse_encode(2, serializer);
9469 <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9470 }
9471 _ => {
9472 unimplemented!("");
9473 }
9474 }
9475 }
9476}
9477
9478impl SseEncode for crate::bindings::SuccessActionProcessed {
9479 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9481 match self {
9482 crate::bindings::SuccessActionProcessed::Aes { result } => {
9483 <i32>::sse_encode(0, serializer);
9484 <crate::bindings::AesSuccessActionDataResult>::sse_encode(result, serializer);
9485 }
9486 crate::bindings::SuccessActionProcessed::Message { data } => {
9487 <i32>::sse_encode(1, serializer);
9488 <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9489 }
9490 crate::bindings::SuccessActionProcessed::Url { data } => {
9491 <i32>::sse_encode(2, serializer);
9492 <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9493 }
9494 _ => {
9495 unimplemented!("");
9496 }
9497 }
9498 }
9499}
9500
9501impl SseEncode for crate::bindings::Symbol {
9502 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9504 <Option<String>>::sse_encode(self.grapheme, serializer);
9505 <Option<String>>::sse_encode(self.template, serializer);
9506 <Option<bool>>::sse_encode(self.rtl, serializer);
9507 <Option<u32>>::sse_encode(self.position, serializer);
9508 }
9509}
9510
9511impl SseEncode for u16 {
9512 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9514 serializer.cursor.write_u16::<NativeEndian>(self).unwrap();
9515 }
9516}
9517
9518impl SseEncode for u32 {
9519 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9521 serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
9522 }
9523}
9524
9525impl SseEncode for u64 {
9526 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9528 serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
9529 }
9530}
9531
9532impl SseEncode for u8 {
9533 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9535 serializer.cursor.write_u8(self).unwrap();
9536 }
9537}
9538
9539impl SseEncode for () {
9540 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
9542}
9543
9544impl SseEncode for crate::bindings::UrlSuccessActionData {
9545 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9547 <String>::sse_encode(self.description, serializer);
9548 <String>::sse_encode(self.url, serializer);
9549 <bool>::sse_encode(self.matches_callback_domain, serializer);
9550 }
9551}
9552
9553impl SseEncode for usize {
9554 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9556 serializer
9557 .cursor
9558 .write_u64::<NativeEndian>(self as _)
9559 .unwrap();
9560 }
9561}
9562
9563impl SseEncode for crate::model::WalletInfo {
9564 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9566 <u64>::sse_encode(self.balance_sat, serializer);
9567 <u64>::sse_encode(self.pending_send_sat, serializer);
9568 <u64>::sse_encode(self.pending_receive_sat, serializer);
9569 <String>::sse_encode(self.fingerprint, serializer);
9570 <String>::sse_encode(self.pubkey, serializer);
9571 <Vec<crate::model::AssetBalance>>::sse_encode(self.asset_balances, serializer);
9572 }
9573}
9574
9575#[cfg(not(target_family = "wasm"))]
9576mod io {
9577 use super::*;
9583 use crate::bindings::*;
9584 use crate::model::EventListener;
9585 use flutter_rust_bridge::for_generated::byteorder::{
9586 NativeEndian, ReadBytesExt, WriteBytesExt,
9587 };
9588 use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
9589 use flutter_rust_bridge::{Handler, IntoIntoDart};
9590
9591 flutter_rust_bridge::frb_generated_boilerplate_io!();
9594
9595 impl CstDecode<flutter_rust_bridge::for_generated::anyhow::Error>
9598 for *mut wire_cst_list_prim_u_8_strict
9599 {
9600 fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error {
9602 unimplemented!()
9603 }
9604 }
9605 impl CstDecode<BindingLiquidSdk> for usize {
9606 fn cst_decode(self) -> BindingLiquidSdk {
9608 flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::<
9609 RustOpaqueNom<
9610 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9611 >,
9612 >::cst_decode(
9613 self
9614 ))
9615 }
9616 }
9617 impl
9618 CstDecode<
9619 RustOpaqueNom<
9620 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9621 >,
9622 > for usize
9623 {
9624 fn cst_decode(
9626 self,
9627 ) -> RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
9628 {
9629 unsafe { decode_rust_opaque_nom(self as _) }
9630 }
9631 }
9632 impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>
9633 for *mut wire_cst_list_prim_u_8_strict
9634 {
9635 fn cst_decode(
9637 self,
9638 ) -> StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
9639 {
9640 let raw: String = self.cst_decode();
9641 StreamSink::deserialize(raw)
9642 }
9643 }
9644 impl CstDecode<StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>>
9645 for *mut wire_cst_list_prim_u_8_strict
9646 {
9647 fn cst_decode(
9649 self,
9650 ) -> StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
9651 {
9652 let raw: String = self.cst_decode();
9653 StreamSink::deserialize(raw)
9654 }
9655 }
9656 impl CstDecode<String> for *mut wire_cst_list_prim_u_8_strict {
9657 fn cst_decode(self) -> String {
9659 let vec: Vec<u8> = self.cst_decode();
9660 String::from_utf8(vec).unwrap()
9661 }
9662 }
9663 impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9664 for wire_cst_accept_payment_proposed_fees_request
9665 {
9666 fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9668 crate::model::AcceptPaymentProposedFeesRequest {
9669 response: self.response.cst_decode(),
9670 }
9671 }
9672 }
9673 impl CstDecode<crate::bindings::AesSuccessActionData> for wire_cst_aes_success_action_data {
9674 fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9676 crate::bindings::AesSuccessActionData {
9677 description: self.description.cst_decode(),
9678 ciphertext: self.ciphertext.cst_decode(),
9679 iv: self.iv.cst_decode(),
9680 }
9681 }
9682 }
9683 impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9684 for wire_cst_aes_success_action_data_decrypted
9685 {
9686 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9688 crate::bindings::AesSuccessActionDataDecrypted {
9689 description: self.description.cst_decode(),
9690 plaintext: self.plaintext.cst_decode(),
9691 }
9692 }
9693 }
9694 impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9695 for wire_cst_aes_success_action_data_result
9696 {
9697 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9699 match self.tag {
9700 0 => {
9701 let ans = unsafe { self.kind.Decrypted };
9702 crate::bindings::AesSuccessActionDataResult::Decrypted {
9703 data: ans.data.cst_decode(),
9704 }
9705 }
9706 1 => {
9707 let ans = unsafe { self.kind.ErrorStatus };
9708 crate::bindings::AesSuccessActionDataResult::ErrorStatus {
9709 reason: ans.reason.cst_decode(),
9710 }
9711 }
9712 _ => unreachable!(),
9713 }
9714 }
9715 }
9716 impl CstDecode<crate::bindings::Amount> for wire_cst_amount {
9717 fn cst_decode(self) -> crate::bindings::Amount {
9719 match self.tag {
9720 0 => {
9721 let ans = unsafe { self.kind.Bitcoin };
9722 crate::bindings::Amount::Bitcoin {
9723 amount_msat: ans.amount_msat.cst_decode(),
9724 }
9725 }
9726 1 => {
9727 let ans = unsafe { self.kind.Currency };
9728 crate::bindings::Amount::Currency {
9729 iso4217_code: ans.iso4217_code.cst_decode(),
9730 fractional_amount: ans.fractional_amount.cst_decode(),
9731 }
9732 }
9733 _ => unreachable!(),
9734 }
9735 }
9736 }
9737 impl CstDecode<crate::model::AssetBalance> for wire_cst_asset_balance {
9738 fn cst_decode(self) -> crate::model::AssetBalance {
9740 crate::model::AssetBalance {
9741 asset_id: self.asset_id.cst_decode(),
9742 balance_sat: self.balance_sat.cst_decode(),
9743 name: self.name.cst_decode(),
9744 ticker: self.ticker.cst_decode(),
9745 balance: self.balance.cst_decode(),
9746 }
9747 }
9748 }
9749 impl CstDecode<crate::model::AssetInfo> for wire_cst_asset_info {
9750 fn cst_decode(self) -> crate::model::AssetInfo {
9752 crate::model::AssetInfo {
9753 name: self.name.cst_decode(),
9754 ticker: self.ticker.cst_decode(),
9755 amount: self.amount.cst_decode(),
9756 fees: self.fees.cst_decode(),
9757 }
9758 }
9759 }
9760 impl CstDecode<crate::model::AssetMetadata> for wire_cst_asset_metadata {
9761 fn cst_decode(self) -> crate::model::AssetMetadata {
9763 crate::model::AssetMetadata {
9764 asset_id: self.asset_id.cst_decode(),
9765 name: self.name.cst_decode(),
9766 ticker: self.ticker.cst_decode(),
9767 precision: self.precision.cst_decode(),
9768 fiat_id: self.fiat_id.cst_decode(),
9769 }
9770 }
9771 }
9772 impl CstDecode<crate::model::BackupRequest> for wire_cst_backup_request {
9773 fn cst_decode(self) -> crate::model::BackupRequest {
9775 crate::model::BackupRequest {
9776 backup_path: self.backup_path.cst_decode(),
9777 }
9778 }
9779 }
9780 impl CstDecode<crate::bindings::BindingEventListener> for wire_cst_binding_event_listener {
9781 fn cst_decode(self) -> crate::bindings::BindingEventListener {
9783 crate::bindings::BindingEventListener {
9784 stream: self.stream.cst_decode(),
9785 }
9786 }
9787 }
9788 impl CstDecode<crate::bindings::BitcoinAddressData> for wire_cst_bitcoin_address_data {
9789 fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9791 crate::bindings::BitcoinAddressData {
9792 address: self.address.cst_decode(),
9793 network: self.network.cst_decode(),
9794 amount_sat: self.amount_sat.cst_decode(),
9795 label: self.label.cst_decode(),
9796 message: self.message.cst_decode(),
9797 }
9798 }
9799 }
9800 impl CstDecode<crate::model::BlockchainExplorer> for wire_cst_blockchain_explorer {
9801 fn cst_decode(self) -> crate::model::BlockchainExplorer {
9803 match self.tag {
9804 0 => {
9805 let ans = unsafe { self.kind.Electrum };
9806 crate::model::BlockchainExplorer::Electrum {
9807 url: ans.url.cst_decode(),
9808 }
9809 }
9810 1 => {
9811 let ans = unsafe { self.kind.Esplora };
9812 crate::model::BlockchainExplorer::Esplora {
9813 url: ans.url.cst_decode(),
9814 use_waterfalls: ans.use_waterfalls.cst_decode(),
9815 }
9816 }
9817 _ => unreachable!(),
9818 }
9819 }
9820 }
9821 impl CstDecode<crate::model::BlockchainInfo> for wire_cst_blockchain_info {
9822 fn cst_decode(self) -> crate::model::BlockchainInfo {
9824 crate::model::BlockchainInfo {
9825 liquid_tip: self.liquid_tip.cst_decode(),
9826 bitcoin_tip: self.bitcoin_tip.cst_decode(),
9827 }
9828 }
9829 }
9830 impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9831 for *mut wire_cst_accept_payment_proposed_fees_request
9832 {
9833 fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9835 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9836 CstDecode::<crate::model::AcceptPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9837 }
9838 }
9839 impl CstDecode<crate::bindings::AesSuccessActionData> for *mut wire_cst_aes_success_action_data {
9840 fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9842 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9843 CstDecode::<crate::bindings::AesSuccessActionData>::cst_decode(*wrap).into()
9844 }
9845 }
9846 impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9847 for *mut wire_cst_aes_success_action_data_decrypted
9848 {
9849 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9851 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9852 CstDecode::<crate::bindings::AesSuccessActionDataDecrypted>::cst_decode(*wrap).into()
9853 }
9854 }
9855 impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9856 for *mut wire_cst_aes_success_action_data_result
9857 {
9858 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9860 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9861 CstDecode::<crate::bindings::AesSuccessActionDataResult>::cst_decode(*wrap).into()
9862 }
9863 }
9864 impl CstDecode<crate::bindings::Amount> for *mut wire_cst_amount {
9865 fn cst_decode(self) -> crate::bindings::Amount {
9867 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9868 CstDecode::<crate::bindings::Amount>::cst_decode(*wrap).into()
9869 }
9870 }
9871 impl CstDecode<crate::model::AssetInfo> for *mut wire_cst_asset_info {
9872 fn cst_decode(self) -> crate::model::AssetInfo {
9874 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9875 CstDecode::<crate::model::AssetInfo>::cst_decode(*wrap).into()
9876 }
9877 }
9878 impl CstDecode<crate::model::BackupRequest> for *mut wire_cst_backup_request {
9879 fn cst_decode(self) -> crate::model::BackupRequest {
9881 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9882 CstDecode::<crate::model::BackupRequest>::cst_decode(*wrap).into()
9883 }
9884 }
9885 impl CstDecode<crate::bindings::BindingEventListener> for *mut wire_cst_binding_event_listener {
9886 fn cst_decode(self) -> crate::bindings::BindingEventListener {
9888 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9889 CstDecode::<crate::bindings::BindingEventListener>::cst_decode(*wrap).into()
9890 }
9891 }
9892 impl CstDecode<crate::bindings::BitcoinAddressData> for *mut wire_cst_bitcoin_address_data {
9893 fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9895 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9896 CstDecode::<crate::bindings::BitcoinAddressData>::cst_decode(*wrap).into()
9897 }
9898 }
9899 impl CstDecode<bool> for *mut bool {
9900 fn cst_decode(self) -> bool {
9902 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9903 }
9904 }
9905 impl CstDecode<crate::model::BuyBitcoinRequest> for *mut wire_cst_buy_bitcoin_request {
9906 fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
9908 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9909 CstDecode::<crate::model::BuyBitcoinRequest>::cst_decode(*wrap).into()
9910 }
9911 }
9912 impl CstDecode<crate::model::CheckMessageRequest> for *mut wire_cst_check_message_request {
9913 fn cst_decode(self) -> crate::model::CheckMessageRequest {
9915 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9916 CstDecode::<crate::model::CheckMessageRequest>::cst_decode(*wrap).into()
9917 }
9918 }
9919 impl CstDecode<crate::model::ConnectRequest> for *mut wire_cst_connect_request {
9920 fn cst_decode(self) -> crate::model::ConnectRequest {
9922 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9923 CstDecode::<crate::model::ConnectRequest>::cst_decode(*wrap).into()
9924 }
9925 }
9926 impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
9927 for *mut wire_cst_create_bolt_12_invoice_request
9928 {
9929 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
9931 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9932 CstDecode::<crate::model::CreateBolt12InvoiceRequest>::cst_decode(*wrap).into()
9933 }
9934 }
9935 impl CstDecode<f64> for *mut f64 {
9936 fn cst_decode(self) -> f64 {
9938 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9939 }
9940 }
9941 impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
9942 for *mut wire_cst_fetch_payment_proposed_fees_request
9943 {
9944 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
9946 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9947 CstDecode::<crate::model::FetchPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9948 }
9949 }
9950 impl CstDecode<crate::model::GetPaymentRequest> for *mut wire_cst_get_payment_request {
9951 fn cst_decode(self) -> crate::model::GetPaymentRequest {
9953 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9954 CstDecode::<crate::model::GetPaymentRequest>::cst_decode(*wrap).into()
9955 }
9956 }
9957 impl CstDecode<i64> for *mut i64 {
9958 fn cst_decode(self) -> i64 {
9960 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9961 }
9962 }
9963 impl CstDecode<crate::bindings::LiquidAddressData> for *mut wire_cst_liquid_address_data {
9964 fn cst_decode(self) -> crate::bindings::LiquidAddressData {
9966 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9967 CstDecode::<crate::bindings::LiquidAddressData>::cst_decode(*wrap).into()
9968 }
9969 }
9970 impl CstDecode<crate::model::ListPaymentDetails> for *mut wire_cst_list_payment_details {
9971 fn cst_decode(self) -> crate::model::ListPaymentDetails {
9973 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9974 CstDecode::<crate::model::ListPaymentDetails>::cst_decode(*wrap).into()
9975 }
9976 }
9977 impl CstDecode<crate::model::ListPaymentsRequest> for *mut wire_cst_list_payments_request {
9978 fn cst_decode(self) -> crate::model::ListPaymentsRequest {
9980 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9981 CstDecode::<crate::model::ListPaymentsRequest>::cst_decode(*wrap).into()
9982 }
9983 }
9984 impl CstDecode<crate::bindings::LNInvoice> for *mut wire_cst_ln_invoice {
9985 fn cst_decode(self) -> crate::bindings::LNInvoice {
9987 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9988 CstDecode::<crate::bindings::LNInvoice>::cst_decode(*wrap).into()
9989 }
9990 }
9991 impl CstDecode<crate::bindings::LNOffer> for *mut wire_cst_ln_offer {
9992 fn cst_decode(self) -> crate::bindings::LNOffer {
9994 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9995 CstDecode::<crate::bindings::LNOffer>::cst_decode(*wrap).into()
9996 }
9997 }
9998 impl CstDecode<crate::bindings::LnUrlAuthRequestData> for *mut wire_cst_ln_url_auth_request_data {
9999 fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10001 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10002 CstDecode::<crate::bindings::LnUrlAuthRequestData>::cst_decode(*wrap).into()
10003 }
10004 }
10005 impl CstDecode<crate::bindings::LnUrlErrorData> for *mut wire_cst_ln_url_error_data {
10006 fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10008 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10009 CstDecode::<crate::bindings::LnUrlErrorData>::cst_decode(*wrap).into()
10010 }
10011 }
10012 impl CstDecode<crate::model::LnUrlInfo> for *mut wire_cst_ln_url_info {
10013 fn cst_decode(self) -> crate::model::LnUrlInfo {
10015 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10016 CstDecode::<crate::model::LnUrlInfo>::cst_decode(*wrap).into()
10017 }
10018 }
10019 impl CstDecode<crate::bindings::LnUrlPayErrorData> for *mut wire_cst_ln_url_pay_error_data {
10020 fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10022 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10023 CstDecode::<crate::bindings::LnUrlPayErrorData>::cst_decode(*wrap).into()
10024 }
10025 }
10026 impl CstDecode<crate::model::LnUrlPayRequest> for *mut wire_cst_ln_url_pay_request {
10027 fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10029 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10030 CstDecode::<crate::model::LnUrlPayRequest>::cst_decode(*wrap).into()
10031 }
10032 }
10033 impl CstDecode<crate::bindings::LnUrlPayRequestData> for *mut wire_cst_ln_url_pay_request_data {
10034 fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10036 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10037 CstDecode::<crate::bindings::LnUrlPayRequestData>::cst_decode(*wrap).into()
10038 }
10039 }
10040 impl CstDecode<crate::model::LnUrlPaySuccessData> for *mut wire_cst_ln_url_pay_success_data {
10041 fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10043 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10044 CstDecode::<crate::model::LnUrlPaySuccessData>::cst_decode(*wrap).into()
10045 }
10046 }
10047 impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for *mut wire_cst_ln_url_withdraw_request {
10048 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
10050 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10051 CstDecode::<crate::bindings::LnUrlWithdrawRequest>::cst_decode(*wrap).into()
10052 }
10053 }
10054 impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
10055 for *mut wire_cst_ln_url_withdraw_request_data
10056 {
10057 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
10059 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10060 CstDecode::<crate::bindings::LnUrlWithdrawRequestData>::cst_decode(*wrap).into()
10061 }
10062 }
10063 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
10064 for *mut wire_cst_ln_url_withdraw_success_data
10065 {
10066 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
10068 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10069 CstDecode::<crate::bindings::duplicates::LnUrlWithdrawSuccessData>::cst_decode(*wrap)
10070 .into()
10071 }
10072 }
10073 impl CstDecode<crate::bindings::MessageSuccessActionData>
10074 for *mut wire_cst_message_success_action_data
10075 {
10076 fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
10078 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10079 CstDecode::<crate::bindings::MessageSuccessActionData>::cst_decode(*wrap).into()
10080 }
10081 }
10082 impl CstDecode<crate::model::PayAmount> for *mut wire_cst_pay_amount {
10083 fn cst_decode(self) -> crate::model::PayAmount {
10085 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10086 CstDecode::<crate::model::PayAmount>::cst_decode(*wrap).into()
10087 }
10088 }
10089 impl CstDecode<crate::model::PayOnchainRequest> for *mut wire_cst_pay_onchain_request {
10090 fn cst_decode(self) -> crate::model::PayOnchainRequest {
10092 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10093 CstDecode::<crate::model::PayOnchainRequest>::cst_decode(*wrap).into()
10094 }
10095 }
10096 impl CstDecode<crate::model::Payment> for *mut wire_cst_payment {
10097 fn cst_decode(self) -> crate::model::Payment {
10099 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10100 CstDecode::<crate::model::Payment>::cst_decode(*wrap).into()
10101 }
10102 }
10103 impl CstDecode<crate::model::PrepareBuyBitcoinRequest>
10104 for *mut wire_cst_prepare_buy_bitcoin_request
10105 {
10106 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
10108 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10109 CstDecode::<crate::model::PrepareBuyBitcoinRequest>::cst_decode(*wrap).into()
10110 }
10111 }
10112 impl CstDecode<crate::model::PrepareLnUrlPayRequest> for *mut wire_cst_prepare_ln_url_pay_request {
10113 fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
10115 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10116 CstDecode::<crate::model::PrepareLnUrlPayRequest>::cst_decode(*wrap).into()
10117 }
10118 }
10119 impl CstDecode<crate::model::PreparePayOnchainRequest>
10120 for *mut wire_cst_prepare_pay_onchain_request
10121 {
10122 fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
10124 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10125 CstDecode::<crate::model::PreparePayOnchainRequest>::cst_decode(*wrap).into()
10126 }
10127 }
10128 impl CstDecode<crate::model::PrepareReceiveRequest> for *mut wire_cst_prepare_receive_request {
10129 fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
10131 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10132 CstDecode::<crate::model::PrepareReceiveRequest>::cst_decode(*wrap).into()
10133 }
10134 }
10135 impl CstDecode<crate::model::PrepareRefundRequest> for *mut wire_cst_prepare_refund_request {
10136 fn cst_decode(self) -> crate::model::PrepareRefundRequest {
10138 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10139 CstDecode::<crate::model::PrepareRefundRequest>::cst_decode(*wrap).into()
10140 }
10141 }
10142 impl CstDecode<crate::model::PrepareSendRequest> for *mut wire_cst_prepare_send_request {
10143 fn cst_decode(self) -> crate::model::PrepareSendRequest {
10145 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10146 CstDecode::<crate::model::PrepareSendRequest>::cst_decode(*wrap).into()
10147 }
10148 }
10149 impl CstDecode<crate::model::ReceiveAmount> for *mut wire_cst_receive_amount {
10150 fn cst_decode(self) -> crate::model::ReceiveAmount {
10152 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10153 CstDecode::<crate::model::ReceiveAmount>::cst_decode(*wrap).into()
10154 }
10155 }
10156 impl CstDecode<crate::model::ReceivePaymentRequest> for *mut wire_cst_receive_payment_request {
10157 fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
10159 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10160 CstDecode::<crate::model::ReceivePaymentRequest>::cst_decode(*wrap).into()
10161 }
10162 }
10163 impl CstDecode<crate::model::RefundRequest> for *mut wire_cst_refund_request {
10164 fn cst_decode(self) -> crate::model::RefundRequest {
10166 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10167 CstDecode::<crate::model::RefundRequest>::cst_decode(*wrap).into()
10168 }
10169 }
10170 impl CstDecode<crate::model::RestoreRequest> for *mut wire_cst_restore_request {
10171 fn cst_decode(self) -> crate::model::RestoreRequest {
10173 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10174 CstDecode::<crate::model::RestoreRequest>::cst_decode(*wrap).into()
10175 }
10176 }
10177 impl CstDecode<crate::model::SdkEvent> for *mut wire_cst_sdk_event {
10178 fn cst_decode(self) -> crate::model::SdkEvent {
10180 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10181 CstDecode::<crate::model::SdkEvent>::cst_decode(*wrap).into()
10182 }
10183 }
10184 impl CstDecode<crate::model::SendPaymentRequest> for *mut wire_cst_send_payment_request {
10185 fn cst_decode(self) -> crate::model::SendPaymentRequest {
10187 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10188 CstDecode::<crate::model::SendPaymentRequest>::cst_decode(*wrap).into()
10189 }
10190 }
10191 impl CstDecode<crate::model::SignMessageRequest> for *mut wire_cst_sign_message_request {
10192 fn cst_decode(self) -> crate::model::SignMessageRequest {
10194 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10195 CstDecode::<crate::model::SignMessageRequest>::cst_decode(*wrap).into()
10196 }
10197 }
10198 impl CstDecode<crate::bindings::SuccessAction> for *mut wire_cst_success_action {
10199 fn cst_decode(self) -> crate::bindings::SuccessAction {
10201 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10202 CstDecode::<crate::bindings::SuccessAction>::cst_decode(*wrap).into()
10203 }
10204 }
10205 impl CstDecode<crate::bindings::SuccessActionProcessed> for *mut wire_cst_success_action_processed {
10206 fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
10208 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10209 CstDecode::<crate::bindings::SuccessActionProcessed>::cst_decode(*wrap).into()
10210 }
10211 }
10212 impl CstDecode<crate::bindings::Symbol> for *mut wire_cst_symbol {
10213 fn cst_decode(self) -> crate::bindings::Symbol {
10215 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10216 CstDecode::<crate::bindings::Symbol>::cst_decode(*wrap).into()
10217 }
10218 }
10219 impl CstDecode<u32> for *mut u32 {
10220 fn cst_decode(self) -> u32 {
10222 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10223 }
10224 }
10225 impl CstDecode<u64> for *mut u64 {
10226 fn cst_decode(self) -> u64 {
10228 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10229 }
10230 }
10231 impl CstDecode<crate::bindings::UrlSuccessActionData> for *mut wire_cst_url_success_action_data {
10232 fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
10234 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10235 CstDecode::<crate::bindings::UrlSuccessActionData>::cst_decode(*wrap).into()
10236 }
10237 }
10238 impl CstDecode<crate::model::BuyBitcoinRequest> for wire_cst_buy_bitcoin_request {
10239 fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
10241 crate::model::BuyBitcoinRequest {
10242 prepare_response: self.prepare_response.cst_decode(),
10243 redirect_url: self.redirect_url.cst_decode(),
10244 }
10245 }
10246 }
10247 impl CstDecode<crate::model::CheckMessageRequest> for wire_cst_check_message_request {
10248 fn cst_decode(self) -> crate::model::CheckMessageRequest {
10250 crate::model::CheckMessageRequest {
10251 message: self.message.cst_decode(),
10252 pubkey: self.pubkey.cst_decode(),
10253 signature: self.signature.cst_decode(),
10254 }
10255 }
10256 }
10257 impl CstDecode<crate::model::CheckMessageResponse> for wire_cst_check_message_response {
10258 fn cst_decode(self) -> crate::model::CheckMessageResponse {
10260 crate::model::CheckMessageResponse {
10261 is_valid: self.is_valid.cst_decode(),
10262 }
10263 }
10264 }
10265 impl CstDecode<crate::model::Config> for wire_cst_config {
10266 fn cst_decode(self) -> crate::model::Config {
10268 crate::model::Config {
10269 liquid_explorer: self.liquid_explorer.cst_decode(),
10270 bitcoin_explorer: self.bitcoin_explorer.cst_decode(),
10271 working_dir: self.working_dir.cst_decode(),
10272 network: self.network.cst_decode(),
10273 payment_timeout_sec: self.payment_timeout_sec.cst_decode(),
10274 sync_service_url: self.sync_service_url.cst_decode(),
10275 zero_conf_max_amount_sat: self.zero_conf_max_amount_sat.cst_decode(),
10276 breez_api_key: self.breez_api_key.cst_decode(),
10277 external_input_parsers: self.external_input_parsers.cst_decode(),
10278 use_default_external_input_parsers: self
10279 .use_default_external_input_parsers
10280 .cst_decode(),
10281 onchain_fee_rate_leeway_sat: self.onchain_fee_rate_leeway_sat.cst_decode(),
10282 asset_metadata: self.asset_metadata.cst_decode(),
10283 sideswap_api_key: self.sideswap_api_key.cst_decode(),
10284 }
10285 }
10286 }
10287 impl CstDecode<crate::model::ConnectRequest> for wire_cst_connect_request {
10288 fn cst_decode(self) -> crate::model::ConnectRequest {
10290 crate::model::ConnectRequest {
10291 config: self.config.cst_decode(),
10292 mnemonic: self.mnemonic.cst_decode(),
10293 passphrase: self.passphrase.cst_decode(),
10294 seed: self.seed.cst_decode(),
10295 }
10296 }
10297 }
10298 impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
10299 for wire_cst_create_bolt_12_invoice_request
10300 {
10301 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
10303 crate::model::CreateBolt12InvoiceRequest {
10304 offer: self.offer.cst_decode(),
10305 invoice_request: self.invoice_request.cst_decode(),
10306 }
10307 }
10308 }
10309 impl CstDecode<crate::model::CreateBolt12InvoiceResponse>
10310 for wire_cst_create_bolt_12_invoice_response
10311 {
10312 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceResponse {
10314 crate::model::CreateBolt12InvoiceResponse {
10315 invoice: self.invoice.cst_decode(),
10316 }
10317 }
10318 }
10319 impl CstDecode<crate::bindings::CurrencyInfo> for wire_cst_currency_info {
10320 fn cst_decode(self) -> crate::bindings::CurrencyInfo {
10322 crate::bindings::CurrencyInfo {
10323 name: self.name.cst_decode(),
10324 fraction_size: self.fraction_size.cst_decode(),
10325 spacing: self.spacing.cst_decode(),
10326 symbol: self.symbol.cst_decode(),
10327 uniq_symbol: self.uniq_symbol.cst_decode(),
10328 localized_name: self.localized_name.cst_decode(),
10329 locale_overrides: self.locale_overrides.cst_decode(),
10330 }
10331 }
10332 }
10333 impl CstDecode<crate::bindings::ExternalInputParser> for wire_cst_external_input_parser {
10334 fn cst_decode(self) -> crate::bindings::ExternalInputParser {
10336 crate::bindings::ExternalInputParser {
10337 provider_id: self.provider_id.cst_decode(),
10338 input_regex: self.input_regex.cst_decode(),
10339 parser_url: self.parser_url.cst_decode(),
10340 }
10341 }
10342 }
10343 impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
10344 for wire_cst_fetch_payment_proposed_fees_request
10345 {
10346 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
10348 crate::model::FetchPaymentProposedFeesRequest {
10349 swap_id: self.swap_id.cst_decode(),
10350 }
10351 }
10352 }
10353 impl CstDecode<crate::model::FetchPaymentProposedFeesResponse>
10354 for wire_cst_fetch_payment_proposed_fees_response
10355 {
10356 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesResponse {
10358 crate::model::FetchPaymentProposedFeesResponse {
10359 swap_id: self.swap_id.cst_decode(),
10360 fees_sat: self.fees_sat.cst_decode(),
10361 payer_amount_sat: self.payer_amount_sat.cst_decode(),
10362 receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
10363 }
10364 }
10365 }
10366 impl CstDecode<crate::bindings::FiatCurrency> for wire_cst_fiat_currency {
10367 fn cst_decode(self) -> crate::bindings::FiatCurrency {
10369 crate::bindings::FiatCurrency {
10370 id: self.id.cst_decode(),
10371 info: self.info.cst_decode(),
10372 }
10373 }
10374 }
10375 impl CstDecode<crate::model::GetInfoResponse> for wire_cst_get_info_response {
10376 fn cst_decode(self) -> crate::model::GetInfoResponse {
10378 crate::model::GetInfoResponse {
10379 wallet_info: self.wallet_info.cst_decode(),
10380 blockchain_info: self.blockchain_info.cst_decode(),
10381 }
10382 }
10383 }
10384 impl CstDecode<crate::model::GetPaymentRequest> for wire_cst_get_payment_request {
10385 fn cst_decode(self) -> crate::model::GetPaymentRequest {
10387 match self.tag {
10388 0 => {
10389 let ans = unsafe { self.kind.PaymentHash };
10390 crate::model::GetPaymentRequest::PaymentHash {
10391 payment_hash: ans.payment_hash.cst_decode(),
10392 }
10393 }
10394 1 => {
10395 let ans = unsafe { self.kind.SwapId };
10396 crate::model::GetPaymentRequest::SwapId {
10397 swap_id: ans.swap_id.cst_decode(),
10398 }
10399 }
10400 _ => unreachable!(),
10401 }
10402 }
10403 }
10404 impl CstDecode<crate::bindings::InputType> for wire_cst_input_type {
10405 fn cst_decode(self) -> crate::bindings::InputType {
10407 match self.tag {
10408 0 => {
10409 let ans = unsafe { self.kind.BitcoinAddress };
10410 crate::bindings::InputType::BitcoinAddress {
10411 address: ans.address.cst_decode(),
10412 }
10413 }
10414 1 => {
10415 let ans = unsafe { self.kind.LiquidAddress };
10416 crate::bindings::InputType::LiquidAddress {
10417 address: ans.address.cst_decode(),
10418 }
10419 }
10420 2 => {
10421 let ans = unsafe { self.kind.Bolt11 };
10422 crate::bindings::InputType::Bolt11 {
10423 invoice: ans.invoice.cst_decode(),
10424 }
10425 }
10426 3 => {
10427 let ans = unsafe { self.kind.Bolt12Offer };
10428 crate::bindings::InputType::Bolt12Offer {
10429 offer: ans.offer.cst_decode(),
10430 bip353_address: ans.bip353_address.cst_decode(),
10431 }
10432 }
10433 4 => {
10434 let ans = unsafe { self.kind.NodeId };
10435 crate::bindings::InputType::NodeId {
10436 node_id: ans.node_id.cst_decode(),
10437 }
10438 }
10439 5 => {
10440 let ans = unsafe { self.kind.Url };
10441 crate::bindings::InputType::Url {
10442 url: ans.url.cst_decode(),
10443 }
10444 }
10445 6 => {
10446 let ans = unsafe { self.kind.LnUrlPay };
10447 crate::bindings::InputType::LnUrlPay {
10448 data: ans.data.cst_decode(),
10449 bip353_address: ans.bip353_address.cst_decode(),
10450 }
10451 }
10452 7 => {
10453 let ans = unsafe { self.kind.LnUrlWithdraw };
10454 crate::bindings::InputType::LnUrlWithdraw {
10455 data: ans.data.cst_decode(),
10456 }
10457 }
10458 8 => {
10459 let ans = unsafe { self.kind.LnUrlAuth };
10460 crate::bindings::InputType::LnUrlAuth {
10461 data: ans.data.cst_decode(),
10462 }
10463 }
10464 9 => {
10465 let ans = unsafe { self.kind.LnUrlError };
10466 crate::bindings::InputType::LnUrlError {
10467 data: ans.data.cst_decode(),
10468 }
10469 }
10470 _ => unreachable!(),
10471 }
10472 }
10473 }
10474 impl CstDecode<crate::model::LightningPaymentLimitsResponse>
10475 for wire_cst_lightning_payment_limits_response
10476 {
10477 fn cst_decode(self) -> crate::model::LightningPaymentLimitsResponse {
10479 crate::model::LightningPaymentLimitsResponse {
10480 send: self.send.cst_decode(),
10481 receive: self.receive.cst_decode(),
10482 }
10483 }
10484 }
10485 impl CstDecode<crate::model::Limits> for wire_cst_limits {
10486 fn cst_decode(self) -> crate::model::Limits {
10488 crate::model::Limits {
10489 min_sat: self.min_sat.cst_decode(),
10490 max_sat: self.max_sat.cst_decode(),
10491 max_zero_conf_sat: self.max_zero_conf_sat.cst_decode(),
10492 }
10493 }
10494 }
10495 impl CstDecode<crate::bindings::LiquidAddressData> for wire_cst_liquid_address_data {
10496 fn cst_decode(self) -> crate::bindings::LiquidAddressData {
10498 crate::bindings::LiquidAddressData {
10499 address: self.address.cst_decode(),
10500 network: self.network.cst_decode(),
10501 asset_id: self.asset_id.cst_decode(),
10502 amount: self.amount.cst_decode(),
10503 amount_sat: self.amount_sat.cst_decode(),
10504 label: self.label.cst_decode(),
10505 message: self.message.cst_decode(),
10506 }
10507 }
10508 }
10509 impl CstDecode<Vec<String>> for *mut wire_cst_list_String {
10510 fn cst_decode(self) -> Vec<String> {
10512 let vec = unsafe {
10513 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10514 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10515 };
10516 vec.into_iter().map(CstDecode::cst_decode).collect()
10517 }
10518 }
10519 impl CstDecode<Vec<crate::model::AssetBalance>> for *mut wire_cst_list_asset_balance {
10520 fn cst_decode(self) -> Vec<crate::model::AssetBalance> {
10522 let vec = unsafe {
10523 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10524 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10525 };
10526 vec.into_iter().map(CstDecode::cst_decode).collect()
10527 }
10528 }
10529 impl CstDecode<Vec<crate::model::AssetMetadata>> for *mut wire_cst_list_asset_metadata {
10530 fn cst_decode(self) -> Vec<crate::model::AssetMetadata> {
10532 let vec = unsafe {
10533 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10534 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10535 };
10536 vec.into_iter().map(CstDecode::cst_decode).collect()
10537 }
10538 }
10539 impl CstDecode<Vec<crate::bindings::ExternalInputParser>>
10540 for *mut wire_cst_list_external_input_parser
10541 {
10542 fn cst_decode(self) -> Vec<crate::bindings::ExternalInputParser> {
10544 let vec = unsafe {
10545 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10546 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10547 };
10548 vec.into_iter().map(CstDecode::cst_decode).collect()
10549 }
10550 }
10551 impl CstDecode<Vec<crate::bindings::FiatCurrency>> for *mut wire_cst_list_fiat_currency {
10552 fn cst_decode(self) -> Vec<crate::bindings::FiatCurrency> {
10554 let vec = unsafe {
10555 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10556 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10557 };
10558 vec.into_iter().map(CstDecode::cst_decode).collect()
10559 }
10560 }
10561 impl CstDecode<Vec<crate::bindings::LnOfferBlindedPath>>
10562 for *mut wire_cst_list_ln_offer_blinded_path
10563 {
10564 fn cst_decode(self) -> Vec<crate::bindings::LnOfferBlindedPath> {
10566 let vec = unsafe {
10567 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10568 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10569 };
10570 vec.into_iter().map(CstDecode::cst_decode).collect()
10571 }
10572 }
10573 impl CstDecode<Vec<crate::bindings::LocaleOverrides>> for *mut wire_cst_list_locale_overrides {
10574 fn cst_decode(self) -> Vec<crate::bindings::LocaleOverrides> {
10576 let vec = unsafe {
10577 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10578 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10579 };
10580 vec.into_iter().map(CstDecode::cst_decode).collect()
10581 }
10582 }
10583 impl CstDecode<Vec<crate::bindings::LocalizedName>> for *mut wire_cst_list_localized_name {
10584 fn cst_decode(self) -> Vec<crate::bindings::LocalizedName> {
10586 let vec = unsafe {
10587 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10588 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10589 };
10590 vec.into_iter().map(CstDecode::cst_decode).collect()
10591 }
10592 }
10593 impl CstDecode<Vec<crate::model::Payment>> for *mut wire_cst_list_payment {
10594 fn cst_decode(self) -> Vec<crate::model::Payment> {
10596 let vec = unsafe {
10597 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10598 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10599 };
10600 vec.into_iter().map(CstDecode::cst_decode).collect()
10601 }
10602 }
10603 impl CstDecode<crate::model::ListPaymentDetails> for wire_cst_list_payment_details {
10604 fn cst_decode(self) -> crate::model::ListPaymentDetails {
10606 match self.tag {
10607 0 => {
10608 let ans = unsafe { self.kind.Liquid };
10609 crate::model::ListPaymentDetails::Liquid {
10610 asset_id: ans.asset_id.cst_decode(),
10611 destination: ans.destination.cst_decode(),
10612 }
10613 }
10614 1 => {
10615 let ans = unsafe { self.kind.Bitcoin };
10616 crate::model::ListPaymentDetails::Bitcoin {
10617 address: ans.address.cst_decode(),
10618 }
10619 }
10620 _ => unreachable!(),
10621 }
10622 }
10623 }
10624 impl CstDecode<Vec<crate::model::PaymentState>> for *mut wire_cst_list_payment_state {
10625 fn cst_decode(self) -> Vec<crate::model::PaymentState> {
10627 let vec = unsafe {
10628 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10629 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10630 };
10631 vec.into_iter().map(CstDecode::cst_decode).collect()
10632 }
10633 }
10634 impl CstDecode<Vec<crate::model::PaymentType>> for *mut wire_cst_list_payment_type {
10635 fn cst_decode(self) -> Vec<crate::model::PaymentType> {
10637 let vec = unsafe {
10638 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10639 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10640 };
10641 vec.into_iter().map(CstDecode::cst_decode).collect()
10642 }
10643 }
10644 impl CstDecode<crate::model::ListPaymentsRequest> for wire_cst_list_payments_request {
10645 fn cst_decode(self) -> crate::model::ListPaymentsRequest {
10647 crate::model::ListPaymentsRequest {
10648 filters: self.filters.cst_decode(),
10649 states: self.states.cst_decode(),
10650 from_timestamp: self.from_timestamp.cst_decode(),
10651 to_timestamp: self.to_timestamp.cst_decode(),
10652 offset: self.offset.cst_decode(),
10653 limit: self.limit.cst_decode(),
10654 details: self.details.cst_decode(),
10655 sort_ascending: self.sort_ascending.cst_decode(),
10656 }
10657 }
10658 }
10659 impl CstDecode<Vec<u8>> for *mut wire_cst_list_prim_u_8_strict {
10660 fn cst_decode(self) -> Vec<u8> {
10662 unsafe {
10663 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10664 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10665 }
10666 }
10667 }
10668 impl CstDecode<Vec<crate::bindings::Rate>> for *mut wire_cst_list_rate {
10669 fn cst_decode(self) -> Vec<crate::bindings::Rate> {
10671 let vec = 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 vec.into_iter().map(CstDecode::cst_decode).collect()
10676 }
10677 }
10678 impl CstDecode<Vec<crate::model::RefundableSwap>> for *mut wire_cst_list_refundable_swap {
10679 fn cst_decode(self) -> Vec<crate::model::RefundableSwap> {
10681 let vec = unsafe {
10682 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10683 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10684 };
10685 vec.into_iter().map(CstDecode::cst_decode).collect()
10686 }
10687 }
10688 impl CstDecode<Vec<crate::bindings::RouteHint>> for *mut wire_cst_list_route_hint {
10689 fn cst_decode(self) -> Vec<crate::bindings::RouteHint> {
10691 let vec = unsafe {
10692 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10693 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10694 };
10695 vec.into_iter().map(CstDecode::cst_decode).collect()
10696 }
10697 }
10698 impl CstDecode<Vec<crate::bindings::RouteHintHop>> for *mut wire_cst_list_route_hint_hop {
10699 fn cst_decode(self) -> Vec<crate::bindings::RouteHintHop> {
10701 let vec = unsafe {
10702 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10703 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10704 };
10705 vec.into_iter().map(CstDecode::cst_decode).collect()
10706 }
10707 }
10708 impl CstDecode<crate::bindings::LNInvoice> for wire_cst_ln_invoice {
10709 fn cst_decode(self) -> crate::bindings::LNInvoice {
10711 crate::bindings::LNInvoice {
10712 bolt11: self.bolt11.cst_decode(),
10713 network: self.network.cst_decode(),
10714 payee_pubkey: self.payee_pubkey.cst_decode(),
10715 payment_hash: self.payment_hash.cst_decode(),
10716 description: self.description.cst_decode(),
10717 description_hash: self.description_hash.cst_decode(),
10718 amount_msat: self.amount_msat.cst_decode(),
10719 timestamp: self.timestamp.cst_decode(),
10720 expiry: self.expiry.cst_decode(),
10721 routing_hints: self.routing_hints.cst_decode(),
10722 payment_secret: self.payment_secret.cst_decode(),
10723 min_final_cltv_expiry_delta: self.min_final_cltv_expiry_delta.cst_decode(),
10724 }
10725 }
10726 }
10727 impl CstDecode<crate::bindings::LNOffer> for wire_cst_ln_offer {
10728 fn cst_decode(self) -> crate::bindings::LNOffer {
10730 crate::bindings::LNOffer {
10731 offer: self.offer.cst_decode(),
10732 chains: self.chains.cst_decode(),
10733 min_amount: self.min_amount.cst_decode(),
10734 description: self.description.cst_decode(),
10735 absolute_expiry: self.absolute_expiry.cst_decode(),
10736 issuer: self.issuer.cst_decode(),
10737 signing_pubkey: self.signing_pubkey.cst_decode(),
10738 paths: self.paths.cst_decode(),
10739 }
10740 }
10741 }
10742 impl CstDecode<crate::bindings::LnOfferBlindedPath> for wire_cst_ln_offer_blinded_path {
10743 fn cst_decode(self) -> crate::bindings::LnOfferBlindedPath {
10745 crate::bindings::LnOfferBlindedPath {
10746 blinded_hops: self.blinded_hops.cst_decode(),
10747 }
10748 }
10749 }
10750 impl CstDecode<crate::bindings::duplicates::LnUrlAuthError> for wire_cst_ln_url_auth_error {
10751 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlAuthError {
10753 match self.tag {
10754 0 => {
10755 let ans = unsafe { self.kind.Generic };
10756 crate::bindings::duplicates::LnUrlAuthError::Generic {
10757 err: ans.err.cst_decode(),
10758 }
10759 }
10760 1 => {
10761 let ans = unsafe { self.kind.InvalidUri };
10762 crate::bindings::duplicates::LnUrlAuthError::InvalidUri {
10763 err: ans.err.cst_decode(),
10764 }
10765 }
10766 2 => {
10767 let ans = unsafe { self.kind.ServiceConnectivity };
10768 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
10769 err: ans.err.cst_decode(),
10770 }
10771 }
10772 _ => unreachable!(),
10773 }
10774 }
10775 }
10776 impl CstDecode<crate::bindings::LnUrlAuthRequestData> for wire_cst_ln_url_auth_request_data {
10777 fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10779 crate::bindings::LnUrlAuthRequestData {
10780 k1: self.k1.cst_decode(),
10781 action: self.action.cst_decode(),
10782 domain: self.domain.cst_decode(),
10783 url: self.url.cst_decode(),
10784 }
10785 }
10786 }
10787 impl CstDecode<crate::bindings::duplicates::LnUrlCallbackStatus>
10788 for wire_cst_ln_url_callback_status
10789 {
10790 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
10792 match self.tag {
10793 0 => crate::bindings::duplicates::LnUrlCallbackStatus::Ok,
10794 1 => {
10795 let ans = unsafe { self.kind.ErrorStatus };
10796 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
10797 data: ans.data.cst_decode(),
10798 }
10799 }
10800 _ => unreachable!(),
10801 }
10802 }
10803 }
10804 impl CstDecode<crate::bindings::LnUrlErrorData> for wire_cst_ln_url_error_data {
10805 fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10807 crate::bindings::LnUrlErrorData {
10808 reason: self.reason.cst_decode(),
10809 }
10810 }
10811 }
10812 impl CstDecode<crate::model::LnUrlInfo> for wire_cst_ln_url_info {
10813 fn cst_decode(self) -> crate::model::LnUrlInfo {
10815 crate::model::LnUrlInfo {
10816 ln_address: self.ln_address.cst_decode(),
10817 lnurl_pay_comment: self.lnurl_pay_comment.cst_decode(),
10818 lnurl_pay_domain: self.lnurl_pay_domain.cst_decode(),
10819 lnurl_pay_metadata: self.lnurl_pay_metadata.cst_decode(),
10820 lnurl_pay_success_action: self.lnurl_pay_success_action.cst_decode(),
10821 lnurl_pay_unprocessed_success_action: self
10822 .lnurl_pay_unprocessed_success_action
10823 .cst_decode(),
10824 lnurl_withdraw_endpoint: self.lnurl_withdraw_endpoint.cst_decode(),
10825 }
10826 }
10827 }
10828 impl CstDecode<crate::bindings::duplicates::LnUrlPayError> for wire_cst_ln_url_pay_error {
10829 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlPayError {
10831 match self.tag {
10832 0 => crate::bindings::duplicates::LnUrlPayError::AlreadyPaid,
10833 1 => {
10834 let ans = unsafe { self.kind.Generic };
10835 crate::bindings::duplicates::LnUrlPayError::Generic {
10836 err: ans.err.cst_decode(),
10837 }
10838 }
10839 2 => {
10840 let ans = unsafe { self.kind.InsufficientBalance };
10841 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
10842 err: ans.err.cst_decode(),
10843 }
10844 }
10845 3 => {
10846 let ans = unsafe { self.kind.InvalidAmount };
10847 crate::bindings::duplicates::LnUrlPayError::InvalidAmount {
10848 err: ans.err.cst_decode(),
10849 }
10850 }
10851 4 => {
10852 let ans = unsafe { self.kind.InvalidInvoice };
10853 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice {
10854 err: ans.err.cst_decode(),
10855 }
10856 }
10857 5 => {
10858 let ans = unsafe { self.kind.InvalidNetwork };
10859 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork {
10860 err: ans.err.cst_decode(),
10861 }
10862 }
10863 6 => {
10864 let ans = unsafe { self.kind.InvalidUri };
10865 crate::bindings::duplicates::LnUrlPayError::InvalidUri {
10866 err: ans.err.cst_decode(),
10867 }
10868 }
10869 7 => {
10870 let ans = unsafe { self.kind.InvoiceExpired };
10871 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired {
10872 err: ans.err.cst_decode(),
10873 }
10874 }
10875 8 => {
10876 let ans = unsafe { self.kind.PaymentFailed };
10877 crate::bindings::duplicates::LnUrlPayError::PaymentFailed {
10878 err: ans.err.cst_decode(),
10879 }
10880 }
10881 9 => {
10882 let ans = unsafe { self.kind.PaymentTimeout };
10883 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout {
10884 err: ans.err.cst_decode(),
10885 }
10886 }
10887 10 => {
10888 let ans = unsafe { self.kind.RouteNotFound };
10889 crate::bindings::duplicates::LnUrlPayError::RouteNotFound {
10890 err: ans.err.cst_decode(),
10891 }
10892 }
10893 11 => {
10894 let ans = unsafe { self.kind.RouteTooExpensive };
10895 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
10896 err: ans.err.cst_decode(),
10897 }
10898 }
10899 12 => {
10900 let ans = unsafe { self.kind.ServiceConnectivity };
10901 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
10902 err: ans.err.cst_decode(),
10903 }
10904 }
10905 _ => unreachable!(),
10906 }
10907 }
10908 }
10909 impl CstDecode<crate::bindings::LnUrlPayErrorData> for wire_cst_ln_url_pay_error_data {
10910 fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10912 crate::bindings::LnUrlPayErrorData {
10913 payment_hash: self.payment_hash.cst_decode(),
10914 reason: self.reason.cst_decode(),
10915 }
10916 }
10917 }
10918 impl CstDecode<crate::model::LnUrlPayRequest> for wire_cst_ln_url_pay_request {
10919 fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10921 crate::model::LnUrlPayRequest {
10922 prepare_response: self.prepare_response.cst_decode(),
10923 }
10924 }
10925 }
10926 impl CstDecode<crate::bindings::LnUrlPayRequestData> for wire_cst_ln_url_pay_request_data {
10927 fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10929 crate::bindings::LnUrlPayRequestData {
10930 callback: self.callback.cst_decode(),
10931 min_sendable: self.min_sendable.cst_decode(),
10932 max_sendable: self.max_sendable.cst_decode(),
10933 metadata_str: self.metadata_str.cst_decode(),
10934 comment_allowed: self.comment_allowed.cst_decode(),
10935 domain: self.domain.cst_decode(),
10936 allows_nostr: self.allows_nostr.cst_decode(),
10937 nostr_pubkey: self.nostr_pubkey.cst_decode(),
10938 ln_address: self.ln_address.cst_decode(),
10939 }
10940 }
10941 }
10942 impl CstDecode<crate::model::LnUrlPayResult> for wire_cst_ln_url_pay_result {
10943 fn cst_decode(self) -> crate::model::LnUrlPayResult {
10945 match self.tag {
10946 0 => {
10947 let ans = unsafe { self.kind.EndpointSuccess };
10948 crate::model::LnUrlPayResult::EndpointSuccess {
10949 data: ans.data.cst_decode(),
10950 }
10951 }
10952 1 => {
10953 let ans = unsafe { self.kind.EndpointError };
10954 crate::model::LnUrlPayResult::EndpointError {
10955 data: ans.data.cst_decode(),
10956 }
10957 }
10958 2 => {
10959 let ans = unsafe { self.kind.PayError };
10960 crate::model::LnUrlPayResult::PayError {
10961 data: ans.data.cst_decode(),
10962 }
10963 }
10964 _ => unreachable!(),
10965 }
10966 }
10967 }
10968 impl CstDecode<crate::model::LnUrlPaySuccessData> for wire_cst_ln_url_pay_success_data {
10969 fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10971 crate::model::LnUrlPaySuccessData {
10972 payment: self.payment.cst_decode(),
10973 success_action: self.success_action.cst_decode(),
10974 }
10975 }
10976 }
10977 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawError> for wire_cst_ln_url_withdraw_error {
10978 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
10980 match self.tag {
10981 0 => {
10982 let ans = unsafe { self.kind.Generic };
10983 crate::bindings::duplicates::LnUrlWithdrawError::Generic {
10984 err: ans.err.cst_decode(),
10985 }
10986 }
10987 1 => {
10988 let ans = unsafe { self.kind.InvalidAmount };
10989 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
10990 err: ans.err.cst_decode(),
10991 }
10992 }
10993 2 => {
10994 let ans = unsafe { self.kind.InvalidInvoice };
10995 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
10996 err: ans.err.cst_decode(),
10997 }
10998 }
10999 3 => {
11000 let ans = unsafe { self.kind.InvalidUri };
11001 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
11002 err: ans.err.cst_decode(),
11003 }
11004 }
11005 4 => {
11006 let ans = unsafe { self.kind.InvoiceNoRoutingHints };
11007 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
11008 err: ans.err.cst_decode(),
11009 }
11010 }
11011 5 => {
11012 let ans = unsafe { self.kind.ServiceConnectivity };
11013 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
11014 err: ans.err.cst_decode(),
11015 }
11016 }
11017 _ => unreachable!(),
11018 }
11019 }
11020 }
11021 impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for wire_cst_ln_url_withdraw_request {
11022 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
11024 crate::bindings::LnUrlWithdrawRequest {
11025 data: self.data.cst_decode(),
11026 amount_msat: self.amount_msat.cst_decode(),
11027 description: self.description.cst_decode(),
11028 }
11029 }
11030 }
11031 impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
11032 for wire_cst_ln_url_withdraw_request_data
11033 {
11034 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
11036 crate::bindings::LnUrlWithdrawRequestData {
11037 callback: self.callback.cst_decode(),
11038 k1: self.k1.cst_decode(),
11039 default_description: self.default_description.cst_decode(),
11040 min_withdrawable: self.min_withdrawable.cst_decode(),
11041 max_withdrawable: self.max_withdrawable.cst_decode(),
11042 }
11043 }
11044 }
11045 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawResult>
11046 for wire_cst_ln_url_withdraw_result
11047 {
11048 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
11050 match self.tag {
11051 0 => {
11052 let ans = unsafe { self.kind.Ok };
11053 crate::bindings::duplicates::LnUrlWithdrawResult::Ok {
11054 data: ans.data.cst_decode(),
11055 }
11056 }
11057 1 => {
11058 let ans = unsafe { self.kind.Timeout };
11059 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
11060 data: ans.data.cst_decode(),
11061 }
11062 }
11063 2 => {
11064 let ans = unsafe { self.kind.ErrorStatus };
11065 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
11066 data: ans.data.cst_decode(),
11067 }
11068 }
11069 _ => unreachable!(),
11070 }
11071 }
11072 }
11073 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
11074 for wire_cst_ln_url_withdraw_success_data
11075 {
11076 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11078 crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11079 invoice: self.invoice.cst_decode(),
11080 }
11081 }
11082 }
11083 impl CstDecode<crate::bindings::LocaleOverrides> for wire_cst_locale_overrides {
11084 fn cst_decode(self) -> crate::bindings::LocaleOverrides {
11086 crate::bindings::LocaleOverrides {
11087 locale: self.locale.cst_decode(),
11088 spacing: self.spacing.cst_decode(),
11089 symbol: self.symbol.cst_decode(),
11090 }
11091 }
11092 }
11093 impl CstDecode<crate::bindings::LocalizedName> for wire_cst_localized_name {
11094 fn cst_decode(self) -> crate::bindings::LocalizedName {
11096 crate::bindings::LocalizedName {
11097 locale: self.locale.cst_decode(),
11098 name: self.name.cst_decode(),
11099 }
11100 }
11101 }
11102 impl CstDecode<crate::model::LogEntry> for wire_cst_log_entry {
11103 fn cst_decode(self) -> crate::model::LogEntry {
11105 crate::model::LogEntry {
11106 line: self.line.cst_decode(),
11107 level: self.level.cst_decode(),
11108 }
11109 }
11110 }
11111 impl CstDecode<crate::bindings::MessageSuccessActionData> for wire_cst_message_success_action_data {
11112 fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
11114 crate::bindings::MessageSuccessActionData {
11115 message: self.message.cst_decode(),
11116 }
11117 }
11118 }
11119 impl CstDecode<crate::model::OnchainPaymentLimitsResponse>
11120 for wire_cst_onchain_payment_limits_response
11121 {
11122 fn cst_decode(self) -> crate::model::OnchainPaymentLimitsResponse {
11124 crate::model::OnchainPaymentLimitsResponse {
11125 send: self.send.cst_decode(),
11126 receive: self.receive.cst_decode(),
11127 }
11128 }
11129 }
11130 impl CstDecode<crate::model::PayAmount> for wire_cst_pay_amount {
11131 fn cst_decode(self) -> crate::model::PayAmount {
11133 match self.tag {
11134 0 => {
11135 let ans = unsafe { self.kind.Bitcoin };
11136 crate::model::PayAmount::Bitcoin {
11137 receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11138 }
11139 }
11140 1 => {
11141 let ans = unsafe { self.kind.Asset };
11142 crate::model::PayAmount::Asset {
11143 asset_id: ans.asset_id.cst_decode(),
11144 receiver_amount: ans.receiver_amount.cst_decode(),
11145 estimate_asset_fees: ans.estimate_asset_fees.cst_decode(),
11146 pay_with_bitcoin: ans.pay_with_bitcoin.cst_decode(),
11147 }
11148 }
11149 2 => crate::model::PayAmount::Drain,
11150 _ => unreachable!(),
11151 }
11152 }
11153 }
11154 impl CstDecode<crate::model::PayOnchainRequest> for wire_cst_pay_onchain_request {
11155 fn cst_decode(self) -> crate::model::PayOnchainRequest {
11157 crate::model::PayOnchainRequest {
11158 address: self.address.cst_decode(),
11159 prepare_response: self.prepare_response.cst_decode(),
11160 }
11161 }
11162 }
11163 impl CstDecode<crate::model::Payment> for wire_cst_payment {
11164 fn cst_decode(self) -> crate::model::Payment {
11166 crate::model::Payment {
11167 destination: self.destination.cst_decode(),
11168 tx_id: self.tx_id.cst_decode(),
11169 unblinding_data: self.unblinding_data.cst_decode(),
11170 timestamp: self.timestamp.cst_decode(),
11171 amount_sat: self.amount_sat.cst_decode(),
11172 fees_sat: self.fees_sat.cst_decode(),
11173 swapper_fees_sat: self.swapper_fees_sat.cst_decode(),
11174 payment_type: self.payment_type.cst_decode(),
11175 status: self.status.cst_decode(),
11176 details: self.details.cst_decode(),
11177 }
11178 }
11179 }
11180 impl CstDecode<crate::model::PaymentDetails> for wire_cst_payment_details {
11181 fn cst_decode(self) -> crate::model::PaymentDetails {
11183 match self.tag {
11184 0 => {
11185 let ans = unsafe { self.kind.Lightning };
11186 crate::model::PaymentDetails::Lightning {
11187 swap_id: ans.swap_id.cst_decode(),
11188 description: ans.description.cst_decode(),
11189 liquid_expiration_blockheight: ans
11190 .liquid_expiration_blockheight
11191 .cst_decode(),
11192 preimage: ans.preimage.cst_decode(),
11193 invoice: ans.invoice.cst_decode(),
11194 bolt12_offer: ans.bolt12_offer.cst_decode(),
11195 payment_hash: ans.payment_hash.cst_decode(),
11196 destination_pubkey: ans.destination_pubkey.cst_decode(),
11197 lnurl_info: ans.lnurl_info.cst_decode(),
11198 bip353_address: ans.bip353_address.cst_decode(),
11199 payer_note: ans.payer_note.cst_decode(),
11200 claim_tx_id: ans.claim_tx_id.cst_decode(),
11201 refund_tx_id: ans.refund_tx_id.cst_decode(),
11202 refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11203 }
11204 }
11205 1 => {
11206 let ans = unsafe { self.kind.Liquid };
11207 crate::model::PaymentDetails::Liquid {
11208 destination: ans.destination.cst_decode(),
11209 description: ans.description.cst_decode(),
11210 asset_id: ans.asset_id.cst_decode(),
11211 asset_info: ans.asset_info.cst_decode(),
11212 lnurl_info: ans.lnurl_info.cst_decode(),
11213 bip353_address: ans.bip353_address.cst_decode(),
11214 payer_note: ans.payer_note.cst_decode(),
11215 }
11216 }
11217 2 => {
11218 let ans = unsafe { self.kind.Bitcoin };
11219 crate::model::PaymentDetails::Bitcoin {
11220 swap_id: ans.swap_id.cst_decode(),
11221 bitcoin_address: ans.bitcoin_address.cst_decode(),
11222 description: ans.description.cst_decode(),
11223 auto_accepted_fees: ans.auto_accepted_fees.cst_decode(),
11224 liquid_expiration_blockheight: ans
11225 .liquid_expiration_blockheight
11226 .cst_decode(),
11227 bitcoin_expiration_blockheight: ans
11228 .bitcoin_expiration_blockheight
11229 .cst_decode(),
11230 lockup_tx_id: ans.lockup_tx_id.cst_decode(),
11231 claim_tx_id: ans.claim_tx_id.cst_decode(),
11232 refund_tx_id: ans.refund_tx_id.cst_decode(),
11233 refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11234 }
11235 }
11236 _ => unreachable!(),
11237 }
11238 }
11239 }
11240 impl CstDecode<crate::error::PaymentError> for wire_cst_payment_error {
11241 fn cst_decode(self) -> crate::error::PaymentError {
11243 match self.tag {
11244 0 => crate::error::PaymentError::AlreadyClaimed,
11245 1 => crate::error::PaymentError::AlreadyPaid,
11246 2 => crate::error::PaymentError::PaymentInProgress,
11247 3 => {
11248 let ans = unsafe { self.kind.AmountOutOfRange };
11249 crate::error::PaymentError::AmountOutOfRange {
11250 min: ans.min.cst_decode(),
11251 max: ans.max.cst_decode(),
11252 }
11253 }
11254 4 => {
11255 let ans = unsafe { self.kind.AmountMissing };
11256 crate::error::PaymentError::AmountMissing {
11257 err: ans.err.cst_decode(),
11258 }
11259 }
11260 5 => {
11261 let ans = unsafe { self.kind.AssetError };
11262 crate::error::PaymentError::AssetError {
11263 err: ans.err.cst_decode(),
11264 }
11265 }
11266 6 => {
11267 let ans = unsafe { self.kind.InvalidNetwork };
11268 crate::error::PaymentError::InvalidNetwork {
11269 err: ans.err.cst_decode(),
11270 }
11271 }
11272 7 => {
11273 let ans = unsafe { self.kind.Generic };
11274 crate::error::PaymentError::Generic {
11275 err: ans.err.cst_decode(),
11276 }
11277 }
11278 8 => crate::error::PaymentError::InvalidOrExpiredFees,
11279 9 => crate::error::PaymentError::InsufficientFunds,
11280 10 => {
11281 let ans = unsafe { self.kind.InvalidDescription };
11282 crate::error::PaymentError::InvalidDescription {
11283 err: ans.err.cst_decode(),
11284 }
11285 }
11286 11 => {
11287 let ans = unsafe { self.kind.InvalidInvoice };
11288 crate::error::PaymentError::InvalidInvoice {
11289 err: ans.err.cst_decode(),
11290 }
11291 }
11292 12 => crate::error::PaymentError::InvalidPreimage,
11293 13 => crate::error::PaymentError::PairsNotFound,
11294 14 => crate::error::PaymentError::PaymentTimeout,
11295 15 => crate::error::PaymentError::PersistError,
11296 16 => {
11297 let ans = unsafe { self.kind.ReceiveError };
11298 crate::error::PaymentError::ReceiveError {
11299 err: ans.err.cst_decode(),
11300 }
11301 }
11302 17 => {
11303 let ans = unsafe { self.kind.Refunded };
11304 crate::error::PaymentError::Refunded {
11305 err: ans.err.cst_decode(),
11306 refund_tx_id: ans.refund_tx_id.cst_decode(),
11307 }
11308 }
11309 18 => crate::error::PaymentError::SelfTransferNotSupported,
11310 19 => {
11311 let ans = unsafe { self.kind.SendError };
11312 crate::error::PaymentError::SendError {
11313 err: ans.err.cst_decode(),
11314 }
11315 }
11316 20 => {
11317 let ans = unsafe { self.kind.SignerError };
11318 crate::error::PaymentError::SignerError {
11319 err: ans.err.cst_decode(),
11320 }
11321 }
11322 _ => unreachable!(),
11323 }
11324 }
11325 }
11326 impl CstDecode<crate::model::PrepareBuyBitcoinRequest> for wire_cst_prepare_buy_bitcoin_request {
11327 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
11329 crate::model::PrepareBuyBitcoinRequest {
11330 provider: self.provider.cst_decode(),
11331 amount_sat: self.amount_sat.cst_decode(),
11332 }
11333 }
11334 }
11335 impl CstDecode<crate::model::PrepareBuyBitcoinResponse> for wire_cst_prepare_buy_bitcoin_response {
11336 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinResponse {
11338 crate::model::PrepareBuyBitcoinResponse {
11339 provider: self.provider.cst_decode(),
11340 amount_sat: self.amount_sat.cst_decode(),
11341 fees_sat: self.fees_sat.cst_decode(),
11342 }
11343 }
11344 }
11345 impl CstDecode<crate::model::PrepareLnUrlPayRequest> for wire_cst_prepare_ln_url_pay_request {
11346 fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
11348 crate::model::PrepareLnUrlPayRequest {
11349 data: self.data.cst_decode(),
11350 amount: self.amount.cst_decode(),
11351 bip353_address: self.bip353_address.cst_decode(),
11352 comment: self.comment.cst_decode(),
11353 validate_success_action_url: self.validate_success_action_url.cst_decode(),
11354 }
11355 }
11356 }
11357 impl CstDecode<crate::model::PrepareLnUrlPayResponse> for wire_cst_prepare_ln_url_pay_response {
11358 fn cst_decode(self) -> crate::model::PrepareLnUrlPayResponse {
11360 crate::model::PrepareLnUrlPayResponse {
11361 destination: self.destination.cst_decode(),
11362 fees_sat: self.fees_sat.cst_decode(),
11363 data: self.data.cst_decode(),
11364 amount: self.amount.cst_decode(),
11365 comment: self.comment.cst_decode(),
11366 success_action: self.success_action.cst_decode(),
11367 }
11368 }
11369 }
11370 impl CstDecode<crate::model::PreparePayOnchainRequest> for wire_cst_prepare_pay_onchain_request {
11371 fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
11373 crate::model::PreparePayOnchainRequest {
11374 amount: self.amount.cst_decode(),
11375 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11376 }
11377 }
11378 }
11379 impl CstDecode<crate::model::PreparePayOnchainResponse> for wire_cst_prepare_pay_onchain_response {
11380 fn cst_decode(self) -> crate::model::PreparePayOnchainResponse {
11382 crate::model::PreparePayOnchainResponse {
11383 receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
11384 claim_fees_sat: self.claim_fees_sat.cst_decode(),
11385 total_fees_sat: self.total_fees_sat.cst_decode(),
11386 }
11387 }
11388 }
11389 impl CstDecode<crate::model::PrepareReceiveRequest> for wire_cst_prepare_receive_request {
11390 fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
11392 crate::model::PrepareReceiveRequest {
11393 payment_method: self.payment_method.cst_decode(),
11394 amount: self.amount.cst_decode(),
11395 }
11396 }
11397 }
11398 impl CstDecode<crate::model::PrepareReceiveResponse> for wire_cst_prepare_receive_response {
11399 fn cst_decode(self) -> crate::model::PrepareReceiveResponse {
11401 crate::model::PrepareReceiveResponse {
11402 payment_method: self.payment_method.cst_decode(),
11403 fees_sat: self.fees_sat.cst_decode(),
11404 amount: self.amount.cst_decode(),
11405 min_payer_amount_sat: self.min_payer_amount_sat.cst_decode(),
11406 max_payer_amount_sat: self.max_payer_amount_sat.cst_decode(),
11407 swapper_feerate: self.swapper_feerate.cst_decode(),
11408 }
11409 }
11410 }
11411 impl CstDecode<crate::model::PrepareRefundRequest> for wire_cst_prepare_refund_request {
11412 fn cst_decode(self) -> crate::model::PrepareRefundRequest {
11414 crate::model::PrepareRefundRequest {
11415 swap_address: self.swap_address.cst_decode(),
11416 refund_address: self.refund_address.cst_decode(),
11417 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11418 }
11419 }
11420 }
11421 impl CstDecode<crate::model::PrepareRefundResponse> for wire_cst_prepare_refund_response {
11422 fn cst_decode(self) -> crate::model::PrepareRefundResponse {
11424 crate::model::PrepareRefundResponse {
11425 tx_vsize: self.tx_vsize.cst_decode(),
11426 tx_fee_sat: self.tx_fee_sat.cst_decode(),
11427 last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11428 }
11429 }
11430 }
11431 impl CstDecode<crate::model::PrepareSendRequest> for wire_cst_prepare_send_request {
11432 fn cst_decode(self) -> crate::model::PrepareSendRequest {
11434 crate::model::PrepareSendRequest {
11435 destination: self.destination.cst_decode(),
11436 amount: self.amount.cst_decode(),
11437 }
11438 }
11439 }
11440 impl CstDecode<crate::model::PrepareSendResponse> for wire_cst_prepare_send_response {
11441 fn cst_decode(self) -> crate::model::PrepareSendResponse {
11443 crate::model::PrepareSendResponse {
11444 destination: self.destination.cst_decode(),
11445 amount: self.amount.cst_decode(),
11446 fees_sat: self.fees_sat.cst_decode(),
11447 estimated_asset_fees: self.estimated_asset_fees.cst_decode(),
11448 }
11449 }
11450 }
11451 impl CstDecode<crate::bindings::Rate> for wire_cst_rate {
11452 fn cst_decode(self) -> crate::bindings::Rate {
11454 crate::bindings::Rate {
11455 coin: self.coin.cst_decode(),
11456 value: self.value.cst_decode(),
11457 }
11458 }
11459 }
11460 impl CstDecode<crate::model::ReceiveAmount> for wire_cst_receive_amount {
11461 fn cst_decode(self) -> crate::model::ReceiveAmount {
11463 match self.tag {
11464 0 => {
11465 let ans = unsafe { self.kind.Bitcoin };
11466 crate::model::ReceiveAmount::Bitcoin {
11467 payer_amount_sat: ans.payer_amount_sat.cst_decode(),
11468 }
11469 }
11470 1 => {
11471 let ans = unsafe { self.kind.Asset };
11472 crate::model::ReceiveAmount::Asset {
11473 asset_id: ans.asset_id.cst_decode(),
11474 payer_amount: ans.payer_amount.cst_decode(),
11475 }
11476 }
11477 _ => unreachable!(),
11478 }
11479 }
11480 }
11481 impl CstDecode<crate::model::ReceivePaymentRequest> for wire_cst_receive_payment_request {
11482 fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
11484 crate::model::ReceivePaymentRequest {
11485 prepare_response: self.prepare_response.cst_decode(),
11486 description: self.description.cst_decode(),
11487 use_description_hash: self.use_description_hash.cst_decode(),
11488 payer_note: self.payer_note.cst_decode(),
11489 }
11490 }
11491 }
11492 impl CstDecode<crate::model::ReceivePaymentResponse> for wire_cst_receive_payment_response {
11493 fn cst_decode(self) -> crate::model::ReceivePaymentResponse {
11495 crate::model::ReceivePaymentResponse {
11496 destination: self.destination.cst_decode(),
11497 }
11498 }
11499 }
11500 impl CstDecode<crate::model::RecommendedFees> for wire_cst_recommended_fees {
11501 fn cst_decode(self) -> crate::model::RecommendedFees {
11503 crate::model::RecommendedFees {
11504 fastest_fee: self.fastest_fee.cst_decode(),
11505 half_hour_fee: self.half_hour_fee.cst_decode(),
11506 hour_fee: self.hour_fee.cst_decode(),
11507 economy_fee: self.economy_fee.cst_decode(),
11508 minimum_fee: self.minimum_fee.cst_decode(),
11509 }
11510 }
11511 }
11512 impl CstDecode<crate::model::RefundRequest> for wire_cst_refund_request {
11513 fn cst_decode(self) -> crate::model::RefundRequest {
11515 crate::model::RefundRequest {
11516 swap_address: self.swap_address.cst_decode(),
11517 refund_address: self.refund_address.cst_decode(),
11518 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11519 }
11520 }
11521 }
11522 impl CstDecode<crate::model::RefundResponse> for wire_cst_refund_response {
11523 fn cst_decode(self) -> crate::model::RefundResponse {
11525 crate::model::RefundResponse {
11526 refund_tx_id: self.refund_tx_id.cst_decode(),
11527 }
11528 }
11529 }
11530 impl CstDecode<crate::model::RefundableSwap> for wire_cst_refundable_swap {
11531 fn cst_decode(self) -> crate::model::RefundableSwap {
11533 crate::model::RefundableSwap {
11534 swap_address: self.swap_address.cst_decode(),
11535 timestamp: self.timestamp.cst_decode(),
11536 amount_sat: self.amount_sat.cst_decode(),
11537 last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11538 }
11539 }
11540 }
11541 impl CstDecode<crate::model::RestoreRequest> for wire_cst_restore_request {
11542 fn cst_decode(self) -> crate::model::RestoreRequest {
11544 crate::model::RestoreRequest {
11545 backup_path: self.backup_path.cst_decode(),
11546 }
11547 }
11548 }
11549 impl CstDecode<crate::bindings::RouteHint> for wire_cst_route_hint {
11550 fn cst_decode(self) -> crate::bindings::RouteHint {
11552 crate::bindings::RouteHint {
11553 hops: self.hops.cst_decode(),
11554 }
11555 }
11556 }
11557 impl CstDecode<crate::bindings::RouteHintHop> for wire_cst_route_hint_hop {
11558 fn cst_decode(self) -> crate::bindings::RouteHintHop {
11560 crate::bindings::RouteHintHop {
11561 src_node_id: self.src_node_id.cst_decode(),
11562 short_channel_id: self.short_channel_id.cst_decode(),
11563 fees_base_msat: self.fees_base_msat.cst_decode(),
11564 fees_proportional_millionths: self.fees_proportional_millionths.cst_decode(),
11565 cltv_expiry_delta: self.cltv_expiry_delta.cst_decode(),
11566 htlc_minimum_msat: self.htlc_minimum_msat.cst_decode(),
11567 htlc_maximum_msat: self.htlc_maximum_msat.cst_decode(),
11568 }
11569 }
11570 }
11571 impl CstDecode<crate::error::SdkError> for wire_cst_sdk_error {
11572 fn cst_decode(self) -> crate::error::SdkError {
11574 match self.tag {
11575 0 => crate::error::SdkError::AlreadyStarted,
11576 1 => {
11577 let ans = unsafe { self.kind.Generic };
11578 crate::error::SdkError::Generic {
11579 err: ans.err.cst_decode(),
11580 }
11581 }
11582 2 => crate::error::SdkError::NotStarted,
11583 3 => {
11584 let ans = unsafe { self.kind.ServiceConnectivity };
11585 crate::error::SdkError::ServiceConnectivity {
11586 err: ans.err.cst_decode(),
11587 }
11588 }
11589 _ => unreachable!(),
11590 }
11591 }
11592 }
11593 impl CstDecode<crate::model::SdkEvent> for wire_cst_sdk_event {
11594 fn cst_decode(self) -> crate::model::SdkEvent {
11596 match self.tag {
11597 0 => {
11598 let ans = unsafe { self.kind.PaymentFailed };
11599 crate::model::SdkEvent::PaymentFailed {
11600 details: ans.details.cst_decode(),
11601 }
11602 }
11603 1 => {
11604 let ans = unsafe { self.kind.PaymentPending };
11605 crate::model::SdkEvent::PaymentPending {
11606 details: ans.details.cst_decode(),
11607 }
11608 }
11609 2 => {
11610 let ans = unsafe { self.kind.PaymentRefundable };
11611 crate::model::SdkEvent::PaymentRefundable {
11612 details: ans.details.cst_decode(),
11613 }
11614 }
11615 3 => {
11616 let ans = unsafe { self.kind.PaymentRefunded };
11617 crate::model::SdkEvent::PaymentRefunded {
11618 details: ans.details.cst_decode(),
11619 }
11620 }
11621 4 => {
11622 let ans = unsafe { self.kind.PaymentRefundPending };
11623 crate::model::SdkEvent::PaymentRefundPending {
11624 details: ans.details.cst_decode(),
11625 }
11626 }
11627 5 => {
11628 let ans = unsafe { self.kind.PaymentSucceeded };
11629 crate::model::SdkEvent::PaymentSucceeded {
11630 details: ans.details.cst_decode(),
11631 }
11632 }
11633 6 => {
11634 let ans = unsafe { self.kind.PaymentWaitingConfirmation };
11635 crate::model::SdkEvent::PaymentWaitingConfirmation {
11636 details: ans.details.cst_decode(),
11637 }
11638 }
11639 7 => {
11640 let ans = unsafe { self.kind.PaymentWaitingFeeAcceptance };
11641 crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
11642 details: ans.details.cst_decode(),
11643 }
11644 }
11645 8 => crate::model::SdkEvent::Synced,
11646 9 => {
11647 let ans = unsafe { self.kind.DataSynced };
11648 crate::model::SdkEvent::DataSynced {
11649 did_pull_new_records: ans.did_pull_new_records.cst_decode(),
11650 }
11651 }
11652 _ => unreachable!(),
11653 }
11654 }
11655 }
11656 impl CstDecode<crate::model::SendDestination> for wire_cst_send_destination {
11657 fn cst_decode(self) -> crate::model::SendDestination {
11659 match self.tag {
11660 0 => {
11661 let ans = unsafe { self.kind.LiquidAddress };
11662 crate::model::SendDestination::LiquidAddress {
11663 address_data: ans.address_data.cst_decode(),
11664 bip353_address: ans.bip353_address.cst_decode(),
11665 }
11666 }
11667 1 => {
11668 let ans = unsafe { self.kind.Bolt11 };
11669 crate::model::SendDestination::Bolt11 {
11670 invoice: ans.invoice.cst_decode(),
11671 bip353_address: ans.bip353_address.cst_decode(),
11672 }
11673 }
11674 2 => {
11675 let ans = unsafe { self.kind.Bolt12 };
11676 crate::model::SendDestination::Bolt12 {
11677 offer: ans.offer.cst_decode(),
11678 receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11679 bip353_address: ans.bip353_address.cst_decode(),
11680 }
11681 }
11682 _ => unreachable!(),
11683 }
11684 }
11685 }
11686 impl CstDecode<crate::model::SendPaymentRequest> for wire_cst_send_payment_request {
11687 fn cst_decode(self) -> crate::model::SendPaymentRequest {
11689 crate::model::SendPaymentRequest {
11690 prepare_response: self.prepare_response.cst_decode(),
11691 use_asset_fees: self.use_asset_fees.cst_decode(),
11692 payer_note: self.payer_note.cst_decode(),
11693 }
11694 }
11695 }
11696 impl CstDecode<crate::model::SendPaymentResponse> for wire_cst_send_payment_response {
11697 fn cst_decode(self) -> crate::model::SendPaymentResponse {
11699 crate::model::SendPaymentResponse {
11700 payment: self.payment.cst_decode(),
11701 }
11702 }
11703 }
11704 impl CstDecode<crate::model::SignMessageRequest> for wire_cst_sign_message_request {
11705 fn cst_decode(self) -> crate::model::SignMessageRequest {
11707 crate::model::SignMessageRequest {
11708 message: self.message.cst_decode(),
11709 }
11710 }
11711 }
11712 impl CstDecode<crate::model::SignMessageResponse> for wire_cst_sign_message_response {
11713 fn cst_decode(self) -> crate::model::SignMessageResponse {
11715 crate::model::SignMessageResponse {
11716 signature: self.signature.cst_decode(),
11717 }
11718 }
11719 }
11720 impl CstDecode<crate::bindings::SuccessAction> for wire_cst_success_action {
11721 fn cst_decode(self) -> crate::bindings::SuccessAction {
11723 match self.tag {
11724 0 => {
11725 let ans = unsafe { self.kind.Aes };
11726 crate::bindings::SuccessAction::Aes {
11727 data: ans.data.cst_decode(),
11728 }
11729 }
11730 1 => {
11731 let ans = unsafe { self.kind.Message };
11732 crate::bindings::SuccessAction::Message {
11733 data: ans.data.cst_decode(),
11734 }
11735 }
11736 2 => {
11737 let ans = unsafe { self.kind.Url };
11738 crate::bindings::SuccessAction::Url {
11739 data: ans.data.cst_decode(),
11740 }
11741 }
11742 _ => unreachable!(),
11743 }
11744 }
11745 }
11746 impl CstDecode<crate::bindings::SuccessActionProcessed> for wire_cst_success_action_processed {
11747 fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
11749 match self.tag {
11750 0 => {
11751 let ans = unsafe { self.kind.Aes };
11752 crate::bindings::SuccessActionProcessed::Aes {
11753 result: ans.result.cst_decode(),
11754 }
11755 }
11756 1 => {
11757 let ans = unsafe { self.kind.Message };
11758 crate::bindings::SuccessActionProcessed::Message {
11759 data: ans.data.cst_decode(),
11760 }
11761 }
11762 2 => {
11763 let ans = unsafe { self.kind.Url };
11764 crate::bindings::SuccessActionProcessed::Url {
11765 data: ans.data.cst_decode(),
11766 }
11767 }
11768 _ => unreachable!(),
11769 }
11770 }
11771 }
11772 impl CstDecode<crate::bindings::Symbol> for wire_cst_symbol {
11773 fn cst_decode(self) -> crate::bindings::Symbol {
11775 crate::bindings::Symbol {
11776 grapheme: self.grapheme.cst_decode(),
11777 template: self.template.cst_decode(),
11778 rtl: self.rtl.cst_decode(),
11779 position: self.position.cst_decode(),
11780 }
11781 }
11782 }
11783 impl CstDecode<crate::bindings::UrlSuccessActionData> for wire_cst_url_success_action_data {
11784 fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
11786 crate::bindings::UrlSuccessActionData {
11787 description: self.description.cst_decode(),
11788 url: self.url.cst_decode(),
11789 matches_callback_domain: self.matches_callback_domain.cst_decode(),
11790 }
11791 }
11792 }
11793 impl CstDecode<crate::model::WalletInfo> for wire_cst_wallet_info {
11794 fn cst_decode(self) -> crate::model::WalletInfo {
11796 crate::model::WalletInfo {
11797 balance_sat: self.balance_sat.cst_decode(),
11798 pending_send_sat: self.pending_send_sat.cst_decode(),
11799 pending_receive_sat: self.pending_receive_sat.cst_decode(),
11800 fingerprint: self.fingerprint.cst_decode(),
11801 pubkey: self.pubkey.cst_decode(),
11802 asset_balances: self.asset_balances.cst_decode(),
11803 }
11804 }
11805 }
11806 impl NewWithNullPtr for wire_cst_accept_payment_proposed_fees_request {
11807 fn new_with_null_ptr() -> Self {
11808 Self {
11809 response: Default::default(),
11810 }
11811 }
11812 }
11813 impl Default for wire_cst_accept_payment_proposed_fees_request {
11814 fn default() -> Self {
11815 Self::new_with_null_ptr()
11816 }
11817 }
11818 impl NewWithNullPtr for wire_cst_aes_success_action_data {
11819 fn new_with_null_ptr() -> Self {
11820 Self {
11821 description: core::ptr::null_mut(),
11822 ciphertext: core::ptr::null_mut(),
11823 iv: core::ptr::null_mut(),
11824 }
11825 }
11826 }
11827 impl Default for wire_cst_aes_success_action_data {
11828 fn default() -> Self {
11829 Self::new_with_null_ptr()
11830 }
11831 }
11832 impl NewWithNullPtr for wire_cst_aes_success_action_data_decrypted {
11833 fn new_with_null_ptr() -> Self {
11834 Self {
11835 description: core::ptr::null_mut(),
11836 plaintext: core::ptr::null_mut(),
11837 }
11838 }
11839 }
11840 impl Default for wire_cst_aes_success_action_data_decrypted {
11841 fn default() -> Self {
11842 Self::new_with_null_ptr()
11843 }
11844 }
11845 impl NewWithNullPtr for wire_cst_aes_success_action_data_result {
11846 fn new_with_null_ptr() -> Self {
11847 Self {
11848 tag: -1,
11849 kind: AesSuccessActionDataResultKind { nil__: () },
11850 }
11851 }
11852 }
11853 impl Default for wire_cst_aes_success_action_data_result {
11854 fn default() -> Self {
11855 Self::new_with_null_ptr()
11856 }
11857 }
11858 impl NewWithNullPtr for wire_cst_amount {
11859 fn new_with_null_ptr() -> Self {
11860 Self {
11861 tag: -1,
11862 kind: AmountKind { nil__: () },
11863 }
11864 }
11865 }
11866 impl Default for wire_cst_amount {
11867 fn default() -> Self {
11868 Self::new_with_null_ptr()
11869 }
11870 }
11871 impl NewWithNullPtr for wire_cst_asset_balance {
11872 fn new_with_null_ptr() -> Self {
11873 Self {
11874 asset_id: core::ptr::null_mut(),
11875 balance_sat: Default::default(),
11876 name: core::ptr::null_mut(),
11877 ticker: core::ptr::null_mut(),
11878 balance: core::ptr::null_mut(),
11879 }
11880 }
11881 }
11882 impl Default for wire_cst_asset_balance {
11883 fn default() -> Self {
11884 Self::new_with_null_ptr()
11885 }
11886 }
11887 impl NewWithNullPtr for wire_cst_asset_info {
11888 fn new_with_null_ptr() -> Self {
11889 Self {
11890 name: core::ptr::null_mut(),
11891 ticker: core::ptr::null_mut(),
11892 amount: Default::default(),
11893 fees: core::ptr::null_mut(),
11894 }
11895 }
11896 }
11897 impl Default for wire_cst_asset_info {
11898 fn default() -> Self {
11899 Self::new_with_null_ptr()
11900 }
11901 }
11902 impl NewWithNullPtr for wire_cst_asset_metadata {
11903 fn new_with_null_ptr() -> Self {
11904 Self {
11905 asset_id: core::ptr::null_mut(),
11906 name: core::ptr::null_mut(),
11907 ticker: core::ptr::null_mut(),
11908 precision: Default::default(),
11909 fiat_id: core::ptr::null_mut(),
11910 }
11911 }
11912 }
11913 impl Default for wire_cst_asset_metadata {
11914 fn default() -> Self {
11915 Self::new_with_null_ptr()
11916 }
11917 }
11918 impl NewWithNullPtr for wire_cst_backup_request {
11919 fn new_with_null_ptr() -> Self {
11920 Self {
11921 backup_path: core::ptr::null_mut(),
11922 }
11923 }
11924 }
11925 impl Default for wire_cst_backup_request {
11926 fn default() -> Self {
11927 Self::new_with_null_ptr()
11928 }
11929 }
11930 impl NewWithNullPtr for wire_cst_binding_event_listener {
11931 fn new_with_null_ptr() -> Self {
11932 Self {
11933 stream: core::ptr::null_mut(),
11934 }
11935 }
11936 }
11937 impl Default for wire_cst_binding_event_listener {
11938 fn default() -> Self {
11939 Self::new_with_null_ptr()
11940 }
11941 }
11942 impl NewWithNullPtr for wire_cst_bitcoin_address_data {
11943 fn new_with_null_ptr() -> Self {
11944 Self {
11945 address: core::ptr::null_mut(),
11946 network: Default::default(),
11947 amount_sat: core::ptr::null_mut(),
11948 label: core::ptr::null_mut(),
11949 message: core::ptr::null_mut(),
11950 }
11951 }
11952 }
11953 impl Default for wire_cst_bitcoin_address_data {
11954 fn default() -> Self {
11955 Self::new_with_null_ptr()
11956 }
11957 }
11958 impl NewWithNullPtr for wire_cst_blockchain_explorer {
11959 fn new_with_null_ptr() -> Self {
11960 Self {
11961 tag: -1,
11962 kind: BlockchainExplorerKind { nil__: () },
11963 }
11964 }
11965 }
11966 impl Default for wire_cst_blockchain_explorer {
11967 fn default() -> Self {
11968 Self::new_with_null_ptr()
11969 }
11970 }
11971 impl NewWithNullPtr for wire_cst_blockchain_info {
11972 fn new_with_null_ptr() -> Self {
11973 Self {
11974 liquid_tip: Default::default(),
11975 bitcoin_tip: Default::default(),
11976 }
11977 }
11978 }
11979 impl Default for wire_cst_blockchain_info {
11980 fn default() -> Self {
11981 Self::new_with_null_ptr()
11982 }
11983 }
11984 impl NewWithNullPtr for wire_cst_buy_bitcoin_request {
11985 fn new_with_null_ptr() -> Self {
11986 Self {
11987 prepare_response: Default::default(),
11988 redirect_url: core::ptr::null_mut(),
11989 }
11990 }
11991 }
11992 impl Default for wire_cst_buy_bitcoin_request {
11993 fn default() -> Self {
11994 Self::new_with_null_ptr()
11995 }
11996 }
11997 impl NewWithNullPtr for wire_cst_check_message_request {
11998 fn new_with_null_ptr() -> Self {
11999 Self {
12000 message: core::ptr::null_mut(),
12001 pubkey: core::ptr::null_mut(),
12002 signature: core::ptr::null_mut(),
12003 }
12004 }
12005 }
12006 impl Default for wire_cst_check_message_request {
12007 fn default() -> Self {
12008 Self::new_with_null_ptr()
12009 }
12010 }
12011 impl NewWithNullPtr for wire_cst_check_message_response {
12012 fn new_with_null_ptr() -> Self {
12013 Self {
12014 is_valid: Default::default(),
12015 }
12016 }
12017 }
12018 impl Default for wire_cst_check_message_response {
12019 fn default() -> Self {
12020 Self::new_with_null_ptr()
12021 }
12022 }
12023 impl NewWithNullPtr for wire_cst_config {
12024 fn new_with_null_ptr() -> Self {
12025 Self {
12026 liquid_explorer: Default::default(),
12027 bitcoin_explorer: Default::default(),
12028 working_dir: core::ptr::null_mut(),
12029 network: Default::default(),
12030 payment_timeout_sec: Default::default(),
12031 sync_service_url: core::ptr::null_mut(),
12032 zero_conf_max_amount_sat: core::ptr::null_mut(),
12033 breez_api_key: core::ptr::null_mut(),
12034 external_input_parsers: core::ptr::null_mut(),
12035 use_default_external_input_parsers: Default::default(),
12036 onchain_fee_rate_leeway_sat: core::ptr::null_mut(),
12037 asset_metadata: core::ptr::null_mut(),
12038 sideswap_api_key: core::ptr::null_mut(),
12039 }
12040 }
12041 }
12042 impl Default for wire_cst_config {
12043 fn default() -> Self {
12044 Self::new_with_null_ptr()
12045 }
12046 }
12047 impl NewWithNullPtr for wire_cst_connect_request {
12048 fn new_with_null_ptr() -> Self {
12049 Self {
12050 config: Default::default(),
12051 mnemonic: core::ptr::null_mut(),
12052 passphrase: core::ptr::null_mut(),
12053 seed: core::ptr::null_mut(),
12054 }
12055 }
12056 }
12057 impl Default for wire_cst_connect_request {
12058 fn default() -> Self {
12059 Self::new_with_null_ptr()
12060 }
12061 }
12062 impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_request {
12063 fn new_with_null_ptr() -> Self {
12064 Self {
12065 offer: core::ptr::null_mut(),
12066 invoice_request: core::ptr::null_mut(),
12067 }
12068 }
12069 }
12070 impl Default for wire_cst_create_bolt_12_invoice_request {
12071 fn default() -> Self {
12072 Self::new_with_null_ptr()
12073 }
12074 }
12075 impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_response {
12076 fn new_with_null_ptr() -> Self {
12077 Self {
12078 invoice: core::ptr::null_mut(),
12079 }
12080 }
12081 }
12082 impl Default for wire_cst_create_bolt_12_invoice_response {
12083 fn default() -> Self {
12084 Self::new_with_null_ptr()
12085 }
12086 }
12087 impl NewWithNullPtr for wire_cst_currency_info {
12088 fn new_with_null_ptr() -> Self {
12089 Self {
12090 name: core::ptr::null_mut(),
12091 fraction_size: Default::default(),
12092 spacing: core::ptr::null_mut(),
12093 symbol: core::ptr::null_mut(),
12094 uniq_symbol: core::ptr::null_mut(),
12095 localized_name: core::ptr::null_mut(),
12096 locale_overrides: core::ptr::null_mut(),
12097 }
12098 }
12099 }
12100 impl Default for wire_cst_currency_info {
12101 fn default() -> Self {
12102 Self::new_with_null_ptr()
12103 }
12104 }
12105 impl NewWithNullPtr for wire_cst_external_input_parser {
12106 fn new_with_null_ptr() -> Self {
12107 Self {
12108 provider_id: core::ptr::null_mut(),
12109 input_regex: core::ptr::null_mut(),
12110 parser_url: core::ptr::null_mut(),
12111 }
12112 }
12113 }
12114 impl Default for wire_cst_external_input_parser {
12115 fn default() -> Self {
12116 Self::new_with_null_ptr()
12117 }
12118 }
12119 impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_request {
12120 fn new_with_null_ptr() -> Self {
12121 Self {
12122 swap_id: core::ptr::null_mut(),
12123 }
12124 }
12125 }
12126 impl Default for wire_cst_fetch_payment_proposed_fees_request {
12127 fn default() -> Self {
12128 Self::new_with_null_ptr()
12129 }
12130 }
12131 impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_response {
12132 fn new_with_null_ptr() -> Self {
12133 Self {
12134 swap_id: core::ptr::null_mut(),
12135 fees_sat: Default::default(),
12136 payer_amount_sat: Default::default(),
12137 receiver_amount_sat: Default::default(),
12138 }
12139 }
12140 }
12141 impl Default for wire_cst_fetch_payment_proposed_fees_response {
12142 fn default() -> Self {
12143 Self::new_with_null_ptr()
12144 }
12145 }
12146 impl NewWithNullPtr for wire_cst_fiat_currency {
12147 fn new_with_null_ptr() -> Self {
12148 Self {
12149 id: core::ptr::null_mut(),
12150 info: Default::default(),
12151 }
12152 }
12153 }
12154 impl Default for wire_cst_fiat_currency {
12155 fn default() -> Self {
12156 Self::new_with_null_ptr()
12157 }
12158 }
12159 impl NewWithNullPtr for wire_cst_get_info_response {
12160 fn new_with_null_ptr() -> Self {
12161 Self {
12162 wallet_info: Default::default(),
12163 blockchain_info: Default::default(),
12164 }
12165 }
12166 }
12167 impl Default for wire_cst_get_info_response {
12168 fn default() -> Self {
12169 Self::new_with_null_ptr()
12170 }
12171 }
12172 impl NewWithNullPtr for wire_cst_get_payment_request {
12173 fn new_with_null_ptr() -> Self {
12174 Self {
12175 tag: -1,
12176 kind: GetPaymentRequestKind { nil__: () },
12177 }
12178 }
12179 }
12180 impl Default for wire_cst_get_payment_request {
12181 fn default() -> Self {
12182 Self::new_with_null_ptr()
12183 }
12184 }
12185 impl NewWithNullPtr for wire_cst_input_type {
12186 fn new_with_null_ptr() -> Self {
12187 Self {
12188 tag: -1,
12189 kind: InputTypeKind { nil__: () },
12190 }
12191 }
12192 }
12193 impl Default for wire_cst_input_type {
12194 fn default() -> Self {
12195 Self::new_with_null_ptr()
12196 }
12197 }
12198 impl NewWithNullPtr for wire_cst_lightning_payment_limits_response {
12199 fn new_with_null_ptr() -> Self {
12200 Self {
12201 send: Default::default(),
12202 receive: Default::default(),
12203 }
12204 }
12205 }
12206 impl Default for wire_cst_lightning_payment_limits_response {
12207 fn default() -> Self {
12208 Self::new_with_null_ptr()
12209 }
12210 }
12211 impl NewWithNullPtr for wire_cst_limits {
12212 fn new_with_null_ptr() -> Self {
12213 Self {
12214 min_sat: Default::default(),
12215 max_sat: Default::default(),
12216 max_zero_conf_sat: Default::default(),
12217 }
12218 }
12219 }
12220 impl Default for wire_cst_limits {
12221 fn default() -> Self {
12222 Self::new_with_null_ptr()
12223 }
12224 }
12225 impl NewWithNullPtr for wire_cst_liquid_address_data {
12226 fn new_with_null_ptr() -> Self {
12227 Self {
12228 address: core::ptr::null_mut(),
12229 network: Default::default(),
12230 asset_id: core::ptr::null_mut(),
12231 amount: core::ptr::null_mut(),
12232 amount_sat: core::ptr::null_mut(),
12233 label: core::ptr::null_mut(),
12234 message: core::ptr::null_mut(),
12235 }
12236 }
12237 }
12238 impl Default for wire_cst_liquid_address_data {
12239 fn default() -> Self {
12240 Self::new_with_null_ptr()
12241 }
12242 }
12243 impl NewWithNullPtr for wire_cst_list_payment_details {
12244 fn new_with_null_ptr() -> Self {
12245 Self {
12246 tag: -1,
12247 kind: ListPaymentDetailsKind { nil__: () },
12248 }
12249 }
12250 }
12251 impl Default for wire_cst_list_payment_details {
12252 fn default() -> Self {
12253 Self::new_with_null_ptr()
12254 }
12255 }
12256 impl NewWithNullPtr for wire_cst_list_payments_request {
12257 fn new_with_null_ptr() -> Self {
12258 Self {
12259 filters: core::ptr::null_mut(),
12260 states: core::ptr::null_mut(),
12261 from_timestamp: core::ptr::null_mut(),
12262 to_timestamp: core::ptr::null_mut(),
12263 offset: core::ptr::null_mut(),
12264 limit: core::ptr::null_mut(),
12265 details: core::ptr::null_mut(),
12266 sort_ascending: core::ptr::null_mut(),
12267 }
12268 }
12269 }
12270 impl Default for wire_cst_list_payments_request {
12271 fn default() -> Self {
12272 Self::new_with_null_ptr()
12273 }
12274 }
12275 impl NewWithNullPtr for wire_cst_ln_invoice {
12276 fn new_with_null_ptr() -> Self {
12277 Self {
12278 bolt11: core::ptr::null_mut(),
12279 network: Default::default(),
12280 payee_pubkey: core::ptr::null_mut(),
12281 payment_hash: core::ptr::null_mut(),
12282 description: core::ptr::null_mut(),
12283 description_hash: core::ptr::null_mut(),
12284 amount_msat: core::ptr::null_mut(),
12285 timestamp: Default::default(),
12286 expiry: Default::default(),
12287 routing_hints: core::ptr::null_mut(),
12288 payment_secret: core::ptr::null_mut(),
12289 min_final_cltv_expiry_delta: Default::default(),
12290 }
12291 }
12292 }
12293 impl Default for wire_cst_ln_invoice {
12294 fn default() -> Self {
12295 Self::new_with_null_ptr()
12296 }
12297 }
12298 impl NewWithNullPtr for wire_cst_ln_offer {
12299 fn new_with_null_ptr() -> Self {
12300 Self {
12301 offer: core::ptr::null_mut(),
12302 chains: core::ptr::null_mut(),
12303 min_amount: core::ptr::null_mut(),
12304 description: core::ptr::null_mut(),
12305 absolute_expiry: core::ptr::null_mut(),
12306 issuer: core::ptr::null_mut(),
12307 signing_pubkey: core::ptr::null_mut(),
12308 paths: core::ptr::null_mut(),
12309 }
12310 }
12311 }
12312 impl Default for wire_cst_ln_offer {
12313 fn default() -> Self {
12314 Self::new_with_null_ptr()
12315 }
12316 }
12317 impl NewWithNullPtr for wire_cst_ln_offer_blinded_path {
12318 fn new_with_null_ptr() -> Self {
12319 Self {
12320 blinded_hops: core::ptr::null_mut(),
12321 }
12322 }
12323 }
12324 impl Default for wire_cst_ln_offer_blinded_path {
12325 fn default() -> Self {
12326 Self::new_with_null_ptr()
12327 }
12328 }
12329 impl NewWithNullPtr for wire_cst_ln_url_auth_error {
12330 fn new_with_null_ptr() -> Self {
12331 Self {
12332 tag: -1,
12333 kind: LnUrlAuthErrorKind { nil__: () },
12334 }
12335 }
12336 }
12337 impl Default for wire_cst_ln_url_auth_error {
12338 fn default() -> Self {
12339 Self::new_with_null_ptr()
12340 }
12341 }
12342 impl NewWithNullPtr for wire_cst_ln_url_auth_request_data {
12343 fn new_with_null_ptr() -> Self {
12344 Self {
12345 k1: core::ptr::null_mut(),
12346 action: core::ptr::null_mut(),
12347 domain: core::ptr::null_mut(),
12348 url: core::ptr::null_mut(),
12349 }
12350 }
12351 }
12352 impl Default for wire_cst_ln_url_auth_request_data {
12353 fn default() -> Self {
12354 Self::new_with_null_ptr()
12355 }
12356 }
12357 impl NewWithNullPtr for wire_cst_ln_url_callback_status {
12358 fn new_with_null_ptr() -> Self {
12359 Self {
12360 tag: -1,
12361 kind: LnUrlCallbackStatusKind { nil__: () },
12362 }
12363 }
12364 }
12365 impl Default for wire_cst_ln_url_callback_status {
12366 fn default() -> Self {
12367 Self::new_with_null_ptr()
12368 }
12369 }
12370 impl NewWithNullPtr for wire_cst_ln_url_error_data {
12371 fn new_with_null_ptr() -> Self {
12372 Self {
12373 reason: core::ptr::null_mut(),
12374 }
12375 }
12376 }
12377 impl Default for wire_cst_ln_url_error_data {
12378 fn default() -> Self {
12379 Self::new_with_null_ptr()
12380 }
12381 }
12382 impl NewWithNullPtr for wire_cst_ln_url_info {
12383 fn new_with_null_ptr() -> Self {
12384 Self {
12385 ln_address: core::ptr::null_mut(),
12386 lnurl_pay_comment: core::ptr::null_mut(),
12387 lnurl_pay_domain: core::ptr::null_mut(),
12388 lnurl_pay_metadata: core::ptr::null_mut(),
12389 lnurl_pay_success_action: core::ptr::null_mut(),
12390 lnurl_pay_unprocessed_success_action: core::ptr::null_mut(),
12391 lnurl_withdraw_endpoint: core::ptr::null_mut(),
12392 }
12393 }
12394 }
12395 impl Default for wire_cst_ln_url_info {
12396 fn default() -> Self {
12397 Self::new_with_null_ptr()
12398 }
12399 }
12400 impl NewWithNullPtr for wire_cst_ln_url_pay_error {
12401 fn new_with_null_ptr() -> Self {
12402 Self {
12403 tag: -1,
12404 kind: LnUrlPayErrorKind { nil__: () },
12405 }
12406 }
12407 }
12408 impl Default for wire_cst_ln_url_pay_error {
12409 fn default() -> Self {
12410 Self::new_with_null_ptr()
12411 }
12412 }
12413 impl NewWithNullPtr for wire_cst_ln_url_pay_error_data {
12414 fn new_with_null_ptr() -> Self {
12415 Self {
12416 payment_hash: core::ptr::null_mut(),
12417 reason: core::ptr::null_mut(),
12418 }
12419 }
12420 }
12421 impl Default for wire_cst_ln_url_pay_error_data {
12422 fn default() -> Self {
12423 Self::new_with_null_ptr()
12424 }
12425 }
12426 impl NewWithNullPtr for wire_cst_ln_url_pay_request {
12427 fn new_with_null_ptr() -> Self {
12428 Self {
12429 prepare_response: Default::default(),
12430 }
12431 }
12432 }
12433 impl Default for wire_cst_ln_url_pay_request {
12434 fn default() -> Self {
12435 Self::new_with_null_ptr()
12436 }
12437 }
12438 impl NewWithNullPtr for wire_cst_ln_url_pay_request_data {
12439 fn new_with_null_ptr() -> Self {
12440 Self {
12441 callback: core::ptr::null_mut(),
12442 min_sendable: Default::default(),
12443 max_sendable: Default::default(),
12444 metadata_str: core::ptr::null_mut(),
12445 comment_allowed: Default::default(),
12446 domain: core::ptr::null_mut(),
12447 allows_nostr: Default::default(),
12448 nostr_pubkey: core::ptr::null_mut(),
12449 ln_address: core::ptr::null_mut(),
12450 }
12451 }
12452 }
12453 impl Default for wire_cst_ln_url_pay_request_data {
12454 fn default() -> Self {
12455 Self::new_with_null_ptr()
12456 }
12457 }
12458 impl NewWithNullPtr for wire_cst_ln_url_pay_result {
12459 fn new_with_null_ptr() -> Self {
12460 Self {
12461 tag: -1,
12462 kind: LnUrlPayResultKind { nil__: () },
12463 }
12464 }
12465 }
12466 impl Default for wire_cst_ln_url_pay_result {
12467 fn default() -> Self {
12468 Self::new_with_null_ptr()
12469 }
12470 }
12471 impl NewWithNullPtr for wire_cst_ln_url_pay_success_data {
12472 fn new_with_null_ptr() -> Self {
12473 Self {
12474 payment: Default::default(),
12475 success_action: core::ptr::null_mut(),
12476 }
12477 }
12478 }
12479 impl Default for wire_cst_ln_url_pay_success_data {
12480 fn default() -> Self {
12481 Self::new_with_null_ptr()
12482 }
12483 }
12484 impl NewWithNullPtr for wire_cst_ln_url_withdraw_error {
12485 fn new_with_null_ptr() -> Self {
12486 Self {
12487 tag: -1,
12488 kind: LnUrlWithdrawErrorKind { nil__: () },
12489 }
12490 }
12491 }
12492 impl Default for wire_cst_ln_url_withdraw_error {
12493 fn default() -> Self {
12494 Self::new_with_null_ptr()
12495 }
12496 }
12497 impl NewWithNullPtr for wire_cst_ln_url_withdraw_request {
12498 fn new_with_null_ptr() -> Self {
12499 Self {
12500 data: Default::default(),
12501 amount_msat: Default::default(),
12502 description: core::ptr::null_mut(),
12503 }
12504 }
12505 }
12506 impl Default for wire_cst_ln_url_withdraw_request {
12507 fn default() -> Self {
12508 Self::new_with_null_ptr()
12509 }
12510 }
12511 impl NewWithNullPtr for wire_cst_ln_url_withdraw_request_data {
12512 fn new_with_null_ptr() -> Self {
12513 Self {
12514 callback: core::ptr::null_mut(),
12515 k1: core::ptr::null_mut(),
12516 default_description: core::ptr::null_mut(),
12517 min_withdrawable: Default::default(),
12518 max_withdrawable: Default::default(),
12519 }
12520 }
12521 }
12522 impl Default for wire_cst_ln_url_withdraw_request_data {
12523 fn default() -> Self {
12524 Self::new_with_null_ptr()
12525 }
12526 }
12527 impl NewWithNullPtr for wire_cst_ln_url_withdraw_result {
12528 fn new_with_null_ptr() -> Self {
12529 Self {
12530 tag: -1,
12531 kind: LnUrlWithdrawResultKind { nil__: () },
12532 }
12533 }
12534 }
12535 impl Default for wire_cst_ln_url_withdraw_result {
12536 fn default() -> Self {
12537 Self::new_with_null_ptr()
12538 }
12539 }
12540 impl NewWithNullPtr for wire_cst_ln_url_withdraw_success_data {
12541 fn new_with_null_ptr() -> Self {
12542 Self {
12543 invoice: Default::default(),
12544 }
12545 }
12546 }
12547 impl Default for wire_cst_ln_url_withdraw_success_data {
12548 fn default() -> Self {
12549 Self::new_with_null_ptr()
12550 }
12551 }
12552 impl NewWithNullPtr for wire_cst_locale_overrides {
12553 fn new_with_null_ptr() -> Self {
12554 Self {
12555 locale: core::ptr::null_mut(),
12556 spacing: core::ptr::null_mut(),
12557 symbol: Default::default(),
12558 }
12559 }
12560 }
12561 impl Default for wire_cst_locale_overrides {
12562 fn default() -> Self {
12563 Self::new_with_null_ptr()
12564 }
12565 }
12566 impl NewWithNullPtr for wire_cst_localized_name {
12567 fn new_with_null_ptr() -> Self {
12568 Self {
12569 locale: core::ptr::null_mut(),
12570 name: core::ptr::null_mut(),
12571 }
12572 }
12573 }
12574 impl Default for wire_cst_localized_name {
12575 fn default() -> Self {
12576 Self::new_with_null_ptr()
12577 }
12578 }
12579 impl NewWithNullPtr for wire_cst_log_entry {
12580 fn new_with_null_ptr() -> Self {
12581 Self {
12582 line: core::ptr::null_mut(),
12583 level: core::ptr::null_mut(),
12584 }
12585 }
12586 }
12587 impl Default for wire_cst_log_entry {
12588 fn default() -> Self {
12589 Self::new_with_null_ptr()
12590 }
12591 }
12592 impl NewWithNullPtr for wire_cst_message_success_action_data {
12593 fn new_with_null_ptr() -> Self {
12594 Self {
12595 message: core::ptr::null_mut(),
12596 }
12597 }
12598 }
12599 impl Default for wire_cst_message_success_action_data {
12600 fn default() -> Self {
12601 Self::new_with_null_ptr()
12602 }
12603 }
12604 impl NewWithNullPtr for wire_cst_onchain_payment_limits_response {
12605 fn new_with_null_ptr() -> Self {
12606 Self {
12607 send: Default::default(),
12608 receive: Default::default(),
12609 }
12610 }
12611 }
12612 impl Default for wire_cst_onchain_payment_limits_response {
12613 fn default() -> Self {
12614 Self::new_with_null_ptr()
12615 }
12616 }
12617 impl NewWithNullPtr for wire_cst_pay_amount {
12618 fn new_with_null_ptr() -> Self {
12619 Self {
12620 tag: -1,
12621 kind: PayAmountKind { nil__: () },
12622 }
12623 }
12624 }
12625 impl Default for wire_cst_pay_amount {
12626 fn default() -> Self {
12627 Self::new_with_null_ptr()
12628 }
12629 }
12630 impl NewWithNullPtr for wire_cst_pay_onchain_request {
12631 fn new_with_null_ptr() -> Self {
12632 Self {
12633 address: core::ptr::null_mut(),
12634 prepare_response: Default::default(),
12635 }
12636 }
12637 }
12638 impl Default for wire_cst_pay_onchain_request {
12639 fn default() -> Self {
12640 Self::new_with_null_ptr()
12641 }
12642 }
12643 impl NewWithNullPtr for wire_cst_payment {
12644 fn new_with_null_ptr() -> Self {
12645 Self {
12646 destination: core::ptr::null_mut(),
12647 tx_id: core::ptr::null_mut(),
12648 unblinding_data: core::ptr::null_mut(),
12649 timestamp: Default::default(),
12650 amount_sat: Default::default(),
12651 fees_sat: Default::default(),
12652 swapper_fees_sat: core::ptr::null_mut(),
12653 payment_type: Default::default(),
12654 status: Default::default(),
12655 details: Default::default(),
12656 }
12657 }
12658 }
12659 impl Default for wire_cst_payment {
12660 fn default() -> Self {
12661 Self::new_with_null_ptr()
12662 }
12663 }
12664 impl NewWithNullPtr for wire_cst_payment_details {
12665 fn new_with_null_ptr() -> Self {
12666 Self {
12667 tag: -1,
12668 kind: PaymentDetailsKind { nil__: () },
12669 }
12670 }
12671 }
12672 impl Default for wire_cst_payment_details {
12673 fn default() -> Self {
12674 Self::new_with_null_ptr()
12675 }
12676 }
12677 impl NewWithNullPtr for wire_cst_payment_error {
12678 fn new_with_null_ptr() -> Self {
12679 Self {
12680 tag: -1,
12681 kind: PaymentErrorKind { nil__: () },
12682 }
12683 }
12684 }
12685 impl Default for wire_cst_payment_error {
12686 fn default() -> Self {
12687 Self::new_with_null_ptr()
12688 }
12689 }
12690 impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_request {
12691 fn new_with_null_ptr() -> Self {
12692 Self {
12693 provider: Default::default(),
12694 amount_sat: Default::default(),
12695 }
12696 }
12697 }
12698 impl Default for wire_cst_prepare_buy_bitcoin_request {
12699 fn default() -> Self {
12700 Self::new_with_null_ptr()
12701 }
12702 }
12703 impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_response {
12704 fn new_with_null_ptr() -> Self {
12705 Self {
12706 provider: Default::default(),
12707 amount_sat: Default::default(),
12708 fees_sat: Default::default(),
12709 }
12710 }
12711 }
12712 impl Default for wire_cst_prepare_buy_bitcoin_response {
12713 fn default() -> Self {
12714 Self::new_with_null_ptr()
12715 }
12716 }
12717 impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_request {
12718 fn new_with_null_ptr() -> Self {
12719 Self {
12720 data: Default::default(),
12721 amount: Default::default(),
12722 bip353_address: core::ptr::null_mut(),
12723 comment: core::ptr::null_mut(),
12724 validate_success_action_url: core::ptr::null_mut(),
12725 }
12726 }
12727 }
12728 impl Default for wire_cst_prepare_ln_url_pay_request {
12729 fn default() -> Self {
12730 Self::new_with_null_ptr()
12731 }
12732 }
12733 impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_response {
12734 fn new_with_null_ptr() -> Self {
12735 Self {
12736 destination: Default::default(),
12737 fees_sat: Default::default(),
12738 data: Default::default(),
12739 amount: Default::default(),
12740 comment: core::ptr::null_mut(),
12741 success_action: core::ptr::null_mut(),
12742 }
12743 }
12744 }
12745 impl Default for wire_cst_prepare_ln_url_pay_response {
12746 fn default() -> Self {
12747 Self::new_with_null_ptr()
12748 }
12749 }
12750 impl NewWithNullPtr for wire_cst_prepare_pay_onchain_request {
12751 fn new_with_null_ptr() -> Self {
12752 Self {
12753 amount: Default::default(),
12754 fee_rate_sat_per_vbyte: core::ptr::null_mut(),
12755 }
12756 }
12757 }
12758 impl Default for wire_cst_prepare_pay_onchain_request {
12759 fn default() -> Self {
12760 Self::new_with_null_ptr()
12761 }
12762 }
12763 impl NewWithNullPtr for wire_cst_prepare_pay_onchain_response {
12764 fn new_with_null_ptr() -> Self {
12765 Self {
12766 receiver_amount_sat: Default::default(),
12767 claim_fees_sat: Default::default(),
12768 total_fees_sat: Default::default(),
12769 }
12770 }
12771 }
12772 impl Default for wire_cst_prepare_pay_onchain_response {
12773 fn default() -> Self {
12774 Self::new_with_null_ptr()
12775 }
12776 }
12777 impl NewWithNullPtr for wire_cst_prepare_receive_request {
12778 fn new_with_null_ptr() -> Self {
12779 Self {
12780 payment_method: Default::default(),
12781 amount: core::ptr::null_mut(),
12782 }
12783 }
12784 }
12785 impl Default for wire_cst_prepare_receive_request {
12786 fn default() -> Self {
12787 Self::new_with_null_ptr()
12788 }
12789 }
12790 impl NewWithNullPtr for wire_cst_prepare_receive_response {
12791 fn new_with_null_ptr() -> Self {
12792 Self {
12793 payment_method: Default::default(),
12794 fees_sat: Default::default(),
12795 amount: core::ptr::null_mut(),
12796 min_payer_amount_sat: core::ptr::null_mut(),
12797 max_payer_amount_sat: core::ptr::null_mut(),
12798 swapper_feerate: core::ptr::null_mut(),
12799 }
12800 }
12801 }
12802 impl Default for wire_cst_prepare_receive_response {
12803 fn default() -> Self {
12804 Self::new_with_null_ptr()
12805 }
12806 }
12807 impl NewWithNullPtr for wire_cst_prepare_refund_request {
12808 fn new_with_null_ptr() -> Self {
12809 Self {
12810 swap_address: core::ptr::null_mut(),
12811 refund_address: core::ptr::null_mut(),
12812 fee_rate_sat_per_vbyte: Default::default(),
12813 }
12814 }
12815 }
12816 impl Default for wire_cst_prepare_refund_request {
12817 fn default() -> Self {
12818 Self::new_with_null_ptr()
12819 }
12820 }
12821 impl NewWithNullPtr for wire_cst_prepare_refund_response {
12822 fn new_with_null_ptr() -> Self {
12823 Self {
12824 tx_vsize: Default::default(),
12825 tx_fee_sat: Default::default(),
12826 last_refund_tx_id: core::ptr::null_mut(),
12827 }
12828 }
12829 }
12830 impl Default for wire_cst_prepare_refund_response {
12831 fn default() -> Self {
12832 Self::new_with_null_ptr()
12833 }
12834 }
12835 impl NewWithNullPtr for wire_cst_prepare_send_request {
12836 fn new_with_null_ptr() -> Self {
12837 Self {
12838 destination: core::ptr::null_mut(),
12839 amount: core::ptr::null_mut(),
12840 }
12841 }
12842 }
12843 impl Default for wire_cst_prepare_send_request {
12844 fn default() -> Self {
12845 Self::new_with_null_ptr()
12846 }
12847 }
12848 impl NewWithNullPtr for wire_cst_prepare_send_response {
12849 fn new_with_null_ptr() -> Self {
12850 Self {
12851 destination: Default::default(),
12852 amount: core::ptr::null_mut(),
12853 fees_sat: core::ptr::null_mut(),
12854 estimated_asset_fees: core::ptr::null_mut(),
12855 }
12856 }
12857 }
12858 impl Default for wire_cst_prepare_send_response {
12859 fn default() -> Self {
12860 Self::new_with_null_ptr()
12861 }
12862 }
12863 impl NewWithNullPtr for wire_cst_rate {
12864 fn new_with_null_ptr() -> Self {
12865 Self {
12866 coin: core::ptr::null_mut(),
12867 value: Default::default(),
12868 }
12869 }
12870 }
12871 impl Default for wire_cst_rate {
12872 fn default() -> Self {
12873 Self::new_with_null_ptr()
12874 }
12875 }
12876 impl NewWithNullPtr for wire_cst_receive_amount {
12877 fn new_with_null_ptr() -> Self {
12878 Self {
12879 tag: -1,
12880 kind: ReceiveAmountKind { nil__: () },
12881 }
12882 }
12883 }
12884 impl Default for wire_cst_receive_amount {
12885 fn default() -> Self {
12886 Self::new_with_null_ptr()
12887 }
12888 }
12889 impl NewWithNullPtr for wire_cst_receive_payment_request {
12890 fn new_with_null_ptr() -> Self {
12891 Self {
12892 prepare_response: Default::default(),
12893 description: core::ptr::null_mut(),
12894 use_description_hash: core::ptr::null_mut(),
12895 payer_note: core::ptr::null_mut(),
12896 }
12897 }
12898 }
12899 impl Default for wire_cst_receive_payment_request {
12900 fn default() -> Self {
12901 Self::new_with_null_ptr()
12902 }
12903 }
12904 impl NewWithNullPtr for wire_cst_receive_payment_response {
12905 fn new_with_null_ptr() -> Self {
12906 Self {
12907 destination: core::ptr::null_mut(),
12908 }
12909 }
12910 }
12911 impl Default for wire_cst_receive_payment_response {
12912 fn default() -> Self {
12913 Self::new_with_null_ptr()
12914 }
12915 }
12916 impl NewWithNullPtr for wire_cst_recommended_fees {
12917 fn new_with_null_ptr() -> Self {
12918 Self {
12919 fastest_fee: Default::default(),
12920 half_hour_fee: Default::default(),
12921 hour_fee: Default::default(),
12922 economy_fee: Default::default(),
12923 minimum_fee: Default::default(),
12924 }
12925 }
12926 }
12927 impl Default for wire_cst_recommended_fees {
12928 fn default() -> Self {
12929 Self::new_with_null_ptr()
12930 }
12931 }
12932 impl NewWithNullPtr for wire_cst_refund_request {
12933 fn new_with_null_ptr() -> Self {
12934 Self {
12935 swap_address: core::ptr::null_mut(),
12936 refund_address: core::ptr::null_mut(),
12937 fee_rate_sat_per_vbyte: Default::default(),
12938 }
12939 }
12940 }
12941 impl Default for wire_cst_refund_request {
12942 fn default() -> Self {
12943 Self::new_with_null_ptr()
12944 }
12945 }
12946 impl NewWithNullPtr for wire_cst_refund_response {
12947 fn new_with_null_ptr() -> Self {
12948 Self {
12949 refund_tx_id: core::ptr::null_mut(),
12950 }
12951 }
12952 }
12953 impl Default for wire_cst_refund_response {
12954 fn default() -> Self {
12955 Self::new_with_null_ptr()
12956 }
12957 }
12958 impl NewWithNullPtr for wire_cst_refundable_swap {
12959 fn new_with_null_ptr() -> Self {
12960 Self {
12961 swap_address: core::ptr::null_mut(),
12962 timestamp: Default::default(),
12963 amount_sat: Default::default(),
12964 last_refund_tx_id: core::ptr::null_mut(),
12965 }
12966 }
12967 }
12968 impl Default for wire_cst_refundable_swap {
12969 fn default() -> Self {
12970 Self::new_with_null_ptr()
12971 }
12972 }
12973 impl NewWithNullPtr for wire_cst_restore_request {
12974 fn new_with_null_ptr() -> Self {
12975 Self {
12976 backup_path: core::ptr::null_mut(),
12977 }
12978 }
12979 }
12980 impl Default for wire_cst_restore_request {
12981 fn default() -> Self {
12982 Self::new_with_null_ptr()
12983 }
12984 }
12985 impl NewWithNullPtr for wire_cst_route_hint {
12986 fn new_with_null_ptr() -> Self {
12987 Self {
12988 hops: core::ptr::null_mut(),
12989 }
12990 }
12991 }
12992 impl Default for wire_cst_route_hint {
12993 fn default() -> Self {
12994 Self::new_with_null_ptr()
12995 }
12996 }
12997 impl NewWithNullPtr for wire_cst_route_hint_hop {
12998 fn new_with_null_ptr() -> Self {
12999 Self {
13000 src_node_id: core::ptr::null_mut(),
13001 short_channel_id: core::ptr::null_mut(),
13002 fees_base_msat: Default::default(),
13003 fees_proportional_millionths: Default::default(),
13004 cltv_expiry_delta: Default::default(),
13005 htlc_minimum_msat: core::ptr::null_mut(),
13006 htlc_maximum_msat: core::ptr::null_mut(),
13007 }
13008 }
13009 }
13010 impl Default for wire_cst_route_hint_hop {
13011 fn default() -> Self {
13012 Self::new_with_null_ptr()
13013 }
13014 }
13015 impl NewWithNullPtr for wire_cst_sdk_error {
13016 fn new_with_null_ptr() -> Self {
13017 Self {
13018 tag: -1,
13019 kind: SdkErrorKind { nil__: () },
13020 }
13021 }
13022 }
13023 impl Default for wire_cst_sdk_error {
13024 fn default() -> Self {
13025 Self::new_with_null_ptr()
13026 }
13027 }
13028 impl NewWithNullPtr for wire_cst_sdk_event {
13029 fn new_with_null_ptr() -> Self {
13030 Self {
13031 tag: -1,
13032 kind: SdkEventKind { nil__: () },
13033 }
13034 }
13035 }
13036 impl Default for wire_cst_sdk_event {
13037 fn default() -> Self {
13038 Self::new_with_null_ptr()
13039 }
13040 }
13041 impl NewWithNullPtr for wire_cst_send_destination {
13042 fn new_with_null_ptr() -> Self {
13043 Self {
13044 tag: -1,
13045 kind: SendDestinationKind { nil__: () },
13046 }
13047 }
13048 }
13049 impl Default for wire_cst_send_destination {
13050 fn default() -> Self {
13051 Self::new_with_null_ptr()
13052 }
13053 }
13054 impl NewWithNullPtr for wire_cst_send_payment_request {
13055 fn new_with_null_ptr() -> Self {
13056 Self {
13057 prepare_response: Default::default(),
13058 use_asset_fees: core::ptr::null_mut(),
13059 payer_note: core::ptr::null_mut(),
13060 }
13061 }
13062 }
13063 impl Default for wire_cst_send_payment_request {
13064 fn default() -> Self {
13065 Self::new_with_null_ptr()
13066 }
13067 }
13068 impl NewWithNullPtr for wire_cst_send_payment_response {
13069 fn new_with_null_ptr() -> Self {
13070 Self {
13071 payment: Default::default(),
13072 }
13073 }
13074 }
13075 impl Default for wire_cst_send_payment_response {
13076 fn default() -> Self {
13077 Self::new_with_null_ptr()
13078 }
13079 }
13080 impl NewWithNullPtr for wire_cst_sign_message_request {
13081 fn new_with_null_ptr() -> Self {
13082 Self {
13083 message: core::ptr::null_mut(),
13084 }
13085 }
13086 }
13087 impl Default for wire_cst_sign_message_request {
13088 fn default() -> Self {
13089 Self::new_with_null_ptr()
13090 }
13091 }
13092 impl NewWithNullPtr for wire_cst_sign_message_response {
13093 fn new_with_null_ptr() -> Self {
13094 Self {
13095 signature: core::ptr::null_mut(),
13096 }
13097 }
13098 }
13099 impl Default for wire_cst_sign_message_response {
13100 fn default() -> Self {
13101 Self::new_with_null_ptr()
13102 }
13103 }
13104 impl NewWithNullPtr for wire_cst_success_action {
13105 fn new_with_null_ptr() -> Self {
13106 Self {
13107 tag: -1,
13108 kind: SuccessActionKind { nil__: () },
13109 }
13110 }
13111 }
13112 impl Default for wire_cst_success_action {
13113 fn default() -> Self {
13114 Self::new_with_null_ptr()
13115 }
13116 }
13117 impl NewWithNullPtr for wire_cst_success_action_processed {
13118 fn new_with_null_ptr() -> Self {
13119 Self {
13120 tag: -1,
13121 kind: SuccessActionProcessedKind { nil__: () },
13122 }
13123 }
13124 }
13125 impl Default for wire_cst_success_action_processed {
13126 fn default() -> Self {
13127 Self::new_with_null_ptr()
13128 }
13129 }
13130 impl NewWithNullPtr for wire_cst_symbol {
13131 fn new_with_null_ptr() -> Self {
13132 Self {
13133 grapheme: core::ptr::null_mut(),
13134 template: core::ptr::null_mut(),
13135 rtl: core::ptr::null_mut(),
13136 position: core::ptr::null_mut(),
13137 }
13138 }
13139 }
13140 impl Default for wire_cst_symbol {
13141 fn default() -> Self {
13142 Self::new_with_null_ptr()
13143 }
13144 }
13145 impl NewWithNullPtr for wire_cst_url_success_action_data {
13146 fn new_with_null_ptr() -> Self {
13147 Self {
13148 description: core::ptr::null_mut(),
13149 url: core::ptr::null_mut(),
13150 matches_callback_domain: Default::default(),
13151 }
13152 }
13153 }
13154 impl Default for wire_cst_url_success_action_data {
13155 fn default() -> Self {
13156 Self::new_with_null_ptr()
13157 }
13158 }
13159 impl NewWithNullPtr for wire_cst_wallet_info {
13160 fn new_with_null_ptr() -> Self {
13161 Self {
13162 balance_sat: Default::default(),
13163 pending_send_sat: Default::default(),
13164 pending_receive_sat: Default::default(),
13165 fingerprint: core::ptr::null_mut(),
13166 pubkey: core::ptr::null_mut(),
13167 asset_balances: core::ptr::null_mut(),
13168 }
13169 }
13170 }
13171 impl Default for wire_cst_wallet_info {
13172 fn default() -> Self {
13173 Self::new_with_null_ptr()
13174 }
13175 }
13176
13177 #[unsafe(no_mangle)]
13178 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees(
13179 port_: i64,
13180 that: usize,
13181 req: *mut wire_cst_accept_payment_proposed_fees_request,
13182 ) {
13183 wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(port_, that, req)
13184 }
13185
13186 #[unsafe(no_mangle)]
13187 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_add_event_listener(
13188 port_: i64,
13189 that: usize,
13190 listener: *mut wire_cst_list_prim_u_8_strict,
13191 ) {
13192 wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(port_, that, listener)
13193 }
13194
13195 #[unsafe(no_mangle)]
13196 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_backup(
13197 that: usize,
13198 req: *mut wire_cst_backup_request,
13199 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13200 wire__crate__bindings__BindingLiquidSdk_backup_impl(that, req)
13201 }
13202
13203 #[unsafe(no_mangle)]
13204 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_buy_bitcoin(
13205 port_: i64,
13206 that: usize,
13207 req: *mut wire_cst_buy_bitcoin_request,
13208 ) {
13209 wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(port_, that, req)
13210 }
13211
13212 #[unsafe(no_mangle)]
13213 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_check_message(
13214 that: usize,
13215 req: *mut wire_cst_check_message_request,
13216 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13217 wire__crate__bindings__BindingLiquidSdk_check_message_impl(that, req)
13218 }
13219
13220 #[unsafe(no_mangle)]
13221 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice(
13222 port_: i64,
13223 that: usize,
13224 req: *mut wire_cst_create_bolt_12_invoice_request,
13225 ) {
13226 wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(port_, that, req)
13227 }
13228
13229 #[unsafe(no_mangle)]
13230 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_disconnect(
13231 port_: i64,
13232 that: usize,
13233 ) {
13234 wire__crate__bindings__BindingLiquidSdk_disconnect_impl(port_, that)
13235 }
13236
13237 #[unsafe(no_mangle)]
13238 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache(
13239 that: usize,
13240 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13241 wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(that)
13242 }
13243
13244 #[unsafe(no_mangle)]
13245 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates(
13246 port_: i64,
13247 that: usize,
13248 ) {
13249 wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(port_, that)
13250 }
13251
13252 #[unsafe(no_mangle)]
13253 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
13254 port_: i64,
13255 that: usize,
13256 ) {
13257 wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(port_, that)
13258 }
13259
13260 #[unsafe(no_mangle)]
13261 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
13262 port_: i64,
13263 that: usize,
13264 ) {
13265 wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(port_, that)
13266 }
13267
13268 #[unsafe(no_mangle)]
13269 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees(
13270 port_: i64,
13271 that: usize,
13272 req: *mut wire_cst_fetch_payment_proposed_fees_request,
13273 ) {
13274 wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(port_, that, req)
13275 }
13276
13277 #[unsafe(no_mangle)]
13278 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info(
13279 port_: i64,
13280 that: usize,
13281 ) {
13282 wire__crate__bindings__BindingLiquidSdk_get_info_impl(port_, that)
13283 }
13284
13285 #[unsafe(no_mangle)]
13286 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_payment(
13287 port_: i64,
13288 that: usize,
13289 req: *mut wire_cst_get_payment_request,
13290 ) {
13291 wire__crate__bindings__BindingLiquidSdk_get_payment_impl(port_, that, req)
13292 }
13293
13294 #[unsafe(no_mangle)]
13295 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies(
13296 port_: i64,
13297 that: usize,
13298 ) {
13299 wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(port_, that)
13300 }
13301
13302 #[unsafe(no_mangle)]
13303 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_payments(
13304 port_: i64,
13305 that: usize,
13306 req: *mut wire_cst_list_payments_request,
13307 ) {
13308 wire__crate__bindings__BindingLiquidSdk_list_payments_impl(port_, that, req)
13309 }
13310
13311 #[unsafe(no_mangle)]
13312 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_refundables(
13313 port_: i64,
13314 that: usize,
13315 ) {
13316 wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(port_, that)
13317 }
13318
13319 #[unsafe(no_mangle)]
13320 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_auth(
13321 port_: i64,
13322 that: usize,
13323 req_data: *mut wire_cst_ln_url_auth_request_data,
13324 ) {
13325 wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(port_, that, req_data)
13326 }
13327
13328 #[unsafe(no_mangle)]
13329 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_pay(
13330 port_: i64,
13331 that: usize,
13332 req: *mut wire_cst_ln_url_pay_request,
13333 ) {
13334 wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(port_, that, req)
13335 }
13336
13337 #[unsafe(no_mangle)]
13338 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw(
13339 port_: i64,
13340 that: usize,
13341 req: *mut wire_cst_ln_url_withdraw_request,
13342 ) {
13343 wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(port_, that, req)
13344 }
13345
13346 #[unsafe(no_mangle)]
13347 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_parse(
13348 port_: i64,
13349 that: usize,
13350 input: *mut wire_cst_list_prim_u_8_strict,
13351 ) {
13352 wire__crate__bindings__BindingLiquidSdk_parse_impl(port_, that, input)
13353 }
13354
13355 #[unsafe(no_mangle)]
13356 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_pay_onchain(
13357 port_: i64,
13358 that: usize,
13359 req: *mut wire_cst_pay_onchain_request,
13360 ) {
13361 wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(port_, that, req)
13362 }
13363
13364 #[unsafe(no_mangle)]
13365 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin(
13366 port_: i64,
13367 that: usize,
13368 req: *mut wire_cst_prepare_buy_bitcoin_request,
13369 ) {
13370 wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(port_, that, req)
13371 }
13372
13373 #[unsafe(no_mangle)]
13374 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay(
13375 port_: i64,
13376 that: usize,
13377 req: *mut wire_cst_prepare_ln_url_pay_request,
13378 ) {
13379 wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(port_, that, req)
13380 }
13381
13382 #[unsafe(no_mangle)]
13383 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain(
13384 port_: i64,
13385 that: usize,
13386 req: *mut wire_cst_prepare_pay_onchain_request,
13387 ) {
13388 wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(port_, that, req)
13389 }
13390
13391 #[unsafe(no_mangle)]
13392 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment(
13393 port_: i64,
13394 that: usize,
13395 req: *mut wire_cst_prepare_receive_request,
13396 ) {
13397 wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(port_, that, req)
13398 }
13399
13400 #[unsafe(no_mangle)]
13401 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_refund(
13402 port_: i64,
13403 that: usize,
13404 req: *mut wire_cst_prepare_refund_request,
13405 ) {
13406 wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(port_, that, req)
13407 }
13408
13409 #[unsafe(no_mangle)]
13410 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_send_payment(
13411 port_: i64,
13412 that: usize,
13413 req: *mut wire_cst_prepare_send_request,
13414 ) {
13415 wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(port_, that, req)
13416 }
13417
13418 #[unsafe(no_mangle)]
13419 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_receive_payment(
13420 port_: i64,
13421 that: usize,
13422 req: *mut wire_cst_receive_payment_request,
13423 ) {
13424 wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(port_, that, req)
13425 }
13426
13427 #[unsafe(no_mangle)]
13428 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_recommended_fees(
13429 port_: i64,
13430 that: usize,
13431 ) {
13432 wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(port_, that)
13433 }
13434
13435 #[unsafe(no_mangle)]
13436 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_refund(
13437 port_: i64,
13438 that: usize,
13439 req: *mut wire_cst_refund_request,
13440 ) {
13441 wire__crate__bindings__BindingLiquidSdk_refund_impl(port_, that, req)
13442 }
13443
13444 #[unsafe(no_mangle)]
13445 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_register_webhook(
13446 port_: i64,
13447 that: usize,
13448 webhook_url: *mut wire_cst_list_prim_u_8_strict,
13449 ) {
13450 wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(port_, that, webhook_url)
13451 }
13452
13453 #[unsafe(no_mangle)]
13454 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps(
13455 port_: i64,
13456 that: usize,
13457 ) {
13458 wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(port_, that)
13459 }
13460
13461 #[unsafe(no_mangle)]
13462 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_restore(
13463 that: usize,
13464 req: *mut wire_cst_restore_request,
13465 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13466 wire__crate__bindings__BindingLiquidSdk_restore_impl(that, req)
13467 }
13468
13469 #[unsafe(no_mangle)]
13470 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_send_payment(
13471 port_: i64,
13472 that: usize,
13473 req: *mut wire_cst_send_payment_request,
13474 ) {
13475 wire__crate__bindings__BindingLiquidSdk_send_payment_impl(port_, that, req)
13476 }
13477
13478 #[unsafe(no_mangle)]
13479 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sign_message(
13480 that: usize,
13481 req: *mut wire_cst_sign_message_request,
13482 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13483 wire__crate__bindings__BindingLiquidSdk_sign_message_impl(that, req)
13484 }
13485
13486 #[unsafe(no_mangle)]
13487 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sync(
13488 port_: i64,
13489 that: usize,
13490 ) {
13491 wire__crate__bindings__BindingLiquidSdk_sync_impl(port_, that)
13492 }
13493
13494 #[unsafe(no_mangle)]
13495 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_unregister_webhook(
13496 port_: i64,
13497 that: usize,
13498 ) {
13499 wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(port_, that)
13500 }
13501
13502 #[unsafe(no_mangle)]
13503 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__binding_event_listener_on_event(
13504 port_: i64,
13505 that: *mut wire_cst_binding_event_listener,
13506 e: *mut wire_cst_sdk_event,
13507 ) {
13508 wire__crate__bindings__binding_event_listener_on_event_impl(port_, that, e)
13509 }
13510
13511 #[unsafe(no_mangle)]
13512 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__breez_log_stream(
13513 port_: i64,
13514 s: *mut wire_cst_list_prim_u_8_strict,
13515 ) {
13516 wire__crate__bindings__breez_log_stream_impl(port_, s)
13517 }
13518
13519 #[unsafe(no_mangle)]
13520 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__connect(
13521 port_: i64,
13522 req: *mut wire_cst_connect_request,
13523 ) {
13524 wire__crate__bindings__connect_impl(port_, req)
13525 }
13526
13527 #[unsafe(no_mangle)]
13528 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__default_config(
13529 network: i32,
13530 breez_api_key: *mut wire_cst_list_prim_u_8_strict,
13531 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13532 wire__crate__bindings__default_config_impl(network, breez_api_key)
13533 }
13534
13535 #[unsafe(no_mangle)]
13536 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__parse_invoice(
13537 input: *mut wire_cst_list_prim_u_8_strict,
13538 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13539 wire__crate__bindings__parse_invoice_impl(input)
13540 }
13541
13542 #[unsafe(no_mangle)]
13543 pub extern "C" fn frbgen_breez_liquid_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13544 ptr: *const std::ffi::c_void,
13545 ) {
13546 unsafe {
13547 StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::increment_strong_count(ptr as _);
13548 }
13549 }
13550
13551 #[unsafe(no_mangle)]
13552 pub extern "C" fn frbgen_breez_liquid_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13553 ptr: *const std::ffi::c_void,
13554 ) {
13555 unsafe {
13556 StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::decrement_strong_count(ptr as _);
13557 }
13558 }
13559
13560 #[unsafe(no_mangle)]
13561 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_accept_payment_proposed_fees_request(
13562 ) -> *mut wire_cst_accept_payment_proposed_fees_request {
13563 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13564 wire_cst_accept_payment_proposed_fees_request::new_with_null_ptr(),
13565 )
13566 }
13567
13568 #[unsafe(no_mangle)]
13569 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data(
13570 ) -> *mut wire_cst_aes_success_action_data {
13571 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13572 wire_cst_aes_success_action_data::new_with_null_ptr(),
13573 )
13574 }
13575
13576 #[unsafe(no_mangle)]
13577 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_decrypted(
13578 ) -> *mut wire_cst_aes_success_action_data_decrypted {
13579 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13580 wire_cst_aes_success_action_data_decrypted::new_with_null_ptr(),
13581 )
13582 }
13583
13584 #[unsafe(no_mangle)]
13585 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_result(
13586 ) -> *mut wire_cst_aes_success_action_data_result {
13587 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13588 wire_cst_aes_success_action_data_result::new_with_null_ptr(),
13589 )
13590 }
13591
13592 #[unsafe(no_mangle)]
13593 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_amount() -> *mut wire_cst_amount {
13594 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_amount::new_with_null_ptr())
13595 }
13596
13597 #[unsafe(no_mangle)]
13598 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_asset_info(
13599 ) -> *mut wire_cst_asset_info {
13600 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13601 wire_cst_asset_info::new_with_null_ptr(),
13602 )
13603 }
13604
13605 #[unsafe(no_mangle)]
13606 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_backup_request(
13607 ) -> *mut wire_cst_backup_request {
13608 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13609 wire_cst_backup_request::new_with_null_ptr(),
13610 )
13611 }
13612
13613 #[unsafe(no_mangle)]
13614 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_binding_event_listener(
13615 ) -> *mut wire_cst_binding_event_listener {
13616 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13617 wire_cst_binding_event_listener::new_with_null_ptr(),
13618 )
13619 }
13620
13621 #[unsafe(no_mangle)]
13622 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bitcoin_address_data(
13623 ) -> *mut wire_cst_bitcoin_address_data {
13624 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13625 wire_cst_bitcoin_address_data::new_with_null_ptr(),
13626 )
13627 }
13628
13629 #[unsafe(no_mangle)]
13630 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bool(value: bool) -> *mut bool {
13631 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13632 }
13633
13634 #[unsafe(no_mangle)]
13635 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_buy_bitcoin_request(
13636 ) -> *mut wire_cst_buy_bitcoin_request {
13637 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13638 wire_cst_buy_bitcoin_request::new_with_null_ptr(),
13639 )
13640 }
13641
13642 #[unsafe(no_mangle)]
13643 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_check_message_request(
13644 ) -> *mut wire_cst_check_message_request {
13645 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13646 wire_cst_check_message_request::new_with_null_ptr(),
13647 )
13648 }
13649
13650 #[unsafe(no_mangle)]
13651 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_connect_request(
13652 ) -> *mut wire_cst_connect_request {
13653 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13654 wire_cst_connect_request::new_with_null_ptr(),
13655 )
13656 }
13657
13658 #[unsafe(no_mangle)]
13659 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_create_bolt_12_invoice_request(
13660 ) -> *mut wire_cst_create_bolt_12_invoice_request {
13661 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13662 wire_cst_create_bolt_12_invoice_request::new_with_null_ptr(),
13663 )
13664 }
13665
13666 #[unsafe(no_mangle)]
13667 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_f_64(value: f64) -> *mut f64 {
13668 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13669 }
13670
13671 #[unsafe(no_mangle)]
13672 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_fetch_payment_proposed_fees_request(
13673 ) -> *mut wire_cst_fetch_payment_proposed_fees_request {
13674 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13675 wire_cst_fetch_payment_proposed_fees_request::new_with_null_ptr(),
13676 )
13677 }
13678
13679 #[unsafe(no_mangle)]
13680 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_get_payment_request(
13681 ) -> *mut wire_cst_get_payment_request {
13682 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13683 wire_cst_get_payment_request::new_with_null_ptr(),
13684 )
13685 }
13686
13687 #[unsafe(no_mangle)]
13688 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_i_64(value: i64) -> *mut i64 {
13689 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13690 }
13691
13692 #[unsafe(no_mangle)]
13693 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_liquid_address_data(
13694 ) -> *mut wire_cst_liquid_address_data {
13695 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13696 wire_cst_liquid_address_data::new_with_null_ptr(),
13697 )
13698 }
13699
13700 #[unsafe(no_mangle)]
13701 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payment_details(
13702 ) -> *mut wire_cst_list_payment_details {
13703 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13704 wire_cst_list_payment_details::new_with_null_ptr(),
13705 )
13706 }
13707
13708 #[unsafe(no_mangle)]
13709 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payments_request(
13710 ) -> *mut wire_cst_list_payments_request {
13711 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13712 wire_cst_list_payments_request::new_with_null_ptr(),
13713 )
13714 }
13715
13716 #[unsafe(no_mangle)]
13717 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_invoice(
13718 ) -> *mut wire_cst_ln_invoice {
13719 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13720 wire_cst_ln_invoice::new_with_null_ptr(),
13721 )
13722 }
13723
13724 #[unsafe(no_mangle)]
13725 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_offer() -> *mut wire_cst_ln_offer {
13726 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_ln_offer::new_with_null_ptr())
13727 }
13728
13729 #[unsafe(no_mangle)]
13730 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_auth_request_data(
13731 ) -> *mut wire_cst_ln_url_auth_request_data {
13732 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13733 wire_cst_ln_url_auth_request_data::new_with_null_ptr(),
13734 )
13735 }
13736
13737 #[unsafe(no_mangle)]
13738 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_error_data(
13739 ) -> *mut wire_cst_ln_url_error_data {
13740 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13741 wire_cst_ln_url_error_data::new_with_null_ptr(),
13742 )
13743 }
13744
13745 #[unsafe(no_mangle)]
13746 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_info(
13747 ) -> *mut wire_cst_ln_url_info {
13748 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13749 wire_cst_ln_url_info::new_with_null_ptr(),
13750 )
13751 }
13752
13753 #[unsafe(no_mangle)]
13754 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_error_data(
13755 ) -> *mut wire_cst_ln_url_pay_error_data {
13756 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13757 wire_cst_ln_url_pay_error_data::new_with_null_ptr(),
13758 )
13759 }
13760
13761 #[unsafe(no_mangle)]
13762 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request(
13763 ) -> *mut wire_cst_ln_url_pay_request {
13764 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13765 wire_cst_ln_url_pay_request::new_with_null_ptr(),
13766 )
13767 }
13768
13769 #[unsafe(no_mangle)]
13770 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request_data(
13771 ) -> *mut wire_cst_ln_url_pay_request_data {
13772 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13773 wire_cst_ln_url_pay_request_data::new_with_null_ptr(),
13774 )
13775 }
13776
13777 #[unsafe(no_mangle)]
13778 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_success_data(
13779 ) -> *mut wire_cst_ln_url_pay_success_data {
13780 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13781 wire_cst_ln_url_pay_success_data::new_with_null_ptr(),
13782 )
13783 }
13784
13785 #[unsafe(no_mangle)]
13786 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request(
13787 ) -> *mut wire_cst_ln_url_withdraw_request {
13788 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13789 wire_cst_ln_url_withdraw_request::new_with_null_ptr(),
13790 )
13791 }
13792
13793 #[unsafe(no_mangle)]
13794 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request_data(
13795 ) -> *mut wire_cst_ln_url_withdraw_request_data {
13796 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13797 wire_cst_ln_url_withdraw_request_data::new_with_null_ptr(),
13798 )
13799 }
13800
13801 #[unsafe(no_mangle)]
13802 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_success_data(
13803 ) -> *mut wire_cst_ln_url_withdraw_success_data {
13804 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13805 wire_cst_ln_url_withdraw_success_data::new_with_null_ptr(),
13806 )
13807 }
13808
13809 #[unsafe(no_mangle)]
13810 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_message_success_action_data(
13811 ) -> *mut wire_cst_message_success_action_data {
13812 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13813 wire_cst_message_success_action_data::new_with_null_ptr(),
13814 )
13815 }
13816
13817 #[unsafe(no_mangle)]
13818 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_amount(
13819 ) -> *mut wire_cst_pay_amount {
13820 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13821 wire_cst_pay_amount::new_with_null_ptr(),
13822 )
13823 }
13824
13825 #[unsafe(no_mangle)]
13826 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_onchain_request(
13827 ) -> *mut wire_cst_pay_onchain_request {
13828 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13829 wire_cst_pay_onchain_request::new_with_null_ptr(),
13830 )
13831 }
13832
13833 #[unsafe(no_mangle)]
13834 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_payment() -> *mut wire_cst_payment {
13835 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_payment::new_with_null_ptr())
13836 }
13837
13838 #[unsafe(no_mangle)]
13839 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_buy_bitcoin_request(
13840 ) -> *mut wire_cst_prepare_buy_bitcoin_request {
13841 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13842 wire_cst_prepare_buy_bitcoin_request::new_with_null_ptr(),
13843 )
13844 }
13845
13846 #[unsafe(no_mangle)]
13847 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_ln_url_pay_request(
13848 ) -> *mut wire_cst_prepare_ln_url_pay_request {
13849 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13850 wire_cst_prepare_ln_url_pay_request::new_with_null_ptr(),
13851 )
13852 }
13853
13854 #[unsafe(no_mangle)]
13855 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_pay_onchain_request(
13856 ) -> *mut wire_cst_prepare_pay_onchain_request {
13857 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13858 wire_cst_prepare_pay_onchain_request::new_with_null_ptr(),
13859 )
13860 }
13861
13862 #[unsafe(no_mangle)]
13863 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_receive_request(
13864 ) -> *mut wire_cst_prepare_receive_request {
13865 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13866 wire_cst_prepare_receive_request::new_with_null_ptr(),
13867 )
13868 }
13869
13870 #[unsafe(no_mangle)]
13871 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_refund_request(
13872 ) -> *mut wire_cst_prepare_refund_request {
13873 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13874 wire_cst_prepare_refund_request::new_with_null_ptr(),
13875 )
13876 }
13877
13878 #[unsafe(no_mangle)]
13879 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_send_request(
13880 ) -> *mut wire_cst_prepare_send_request {
13881 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13882 wire_cst_prepare_send_request::new_with_null_ptr(),
13883 )
13884 }
13885
13886 #[unsafe(no_mangle)]
13887 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_amount(
13888 ) -> *mut wire_cst_receive_amount {
13889 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13890 wire_cst_receive_amount::new_with_null_ptr(),
13891 )
13892 }
13893
13894 #[unsafe(no_mangle)]
13895 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_payment_request(
13896 ) -> *mut wire_cst_receive_payment_request {
13897 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13898 wire_cst_receive_payment_request::new_with_null_ptr(),
13899 )
13900 }
13901
13902 #[unsafe(no_mangle)]
13903 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_refund_request(
13904 ) -> *mut wire_cst_refund_request {
13905 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13906 wire_cst_refund_request::new_with_null_ptr(),
13907 )
13908 }
13909
13910 #[unsafe(no_mangle)]
13911 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_restore_request(
13912 ) -> *mut wire_cst_restore_request {
13913 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13914 wire_cst_restore_request::new_with_null_ptr(),
13915 )
13916 }
13917
13918 #[unsafe(no_mangle)]
13919 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sdk_event() -> *mut wire_cst_sdk_event
13920 {
13921 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_sdk_event::new_with_null_ptr())
13922 }
13923
13924 #[unsafe(no_mangle)]
13925 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_send_payment_request(
13926 ) -> *mut wire_cst_send_payment_request {
13927 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13928 wire_cst_send_payment_request::new_with_null_ptr(),
13929 )
13930 }
13931
13932 #[unsafe(no_mangle)]
13933 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sign_message_request(
13934 ) -> *mut wire_cst_sign_message_request {
13935 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13936 wire_cst_sign_message_request::new_with_null_ptr(),
13937 )
13938 }
13939
13940 #[unsafe(no_mangle)]
13941 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action(
13942 ) -> *mut wire_cst_success_action {
13943 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13944 wire_cst_success_action::new_with_null_ptr(),
13945 )
13946 }
13947
13948 #[unsafe(no_mangle)]
13949 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action_processed(
13950 ) -> *mut wire_cst_success_action_processed {
13951 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13952 wire_cst_success_action_processed::new_with_null_ptr(),
13953 )
13954 }
13955
13956 #[unsafe(no_mangle)]
13957 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_symbol() -> *mut wire_cst_symbol {
13958 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_symbol::new_with_null_ptr())
13959 }
13960
13961 #[unsafe(no_mangle)]
13962 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_32(value: u32) -> *mut u32 {
13963 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13964 }
13965
13966 #[unsafe(no_mangle)]
13967 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_64(value: u64) -> *mut u64 {
13968 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13969 }
13970
13971 #[unsafe(no_mangle)]
13972 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_url_success_action_data(
13973 ) -> *mut wire_cst_url_success_action_data {
13974 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13975 wire_cst_url_success_action_data::new_with_null_ptr(),
13976 )
13977 }
13978
13979 #[unsafe(no_mangle)]
13980 pub extern "C" fn frbgen_breez_liquid_cst_new_list_String(
13981 len: i32,
13982 ) -> *mut wire_cst_list_String {
13983 let wrap = wire_cst_list_String {
13984 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13985 <*mut wire_cst_list_prim_u_8_strict>::new_with_null_ptr(),
13986 len,
13987 ),
13988 len,
13989 };
13990 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13991 }
13992
13993 #[unsafe(no_mangle)]
13994 pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_balance(
13995 len: i32,
13996 ) -> *mut wire_cst_list_asset_balance {
13997 let wrap = wire_cst_list_asset_balance {
13998 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13999 <wire_cst_asset_balance>::new_with_null_ptr(),
14000 len,
14001 ),
14002 len,
14003 };
14004 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14005 }
14006
14007 #[unsafe(no_mangle)]
14008 pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_metadata(
14009 len: i32,
14010 ) -> *mut wire_cst_list_asset_metadata {
14011 let wrap = wire_cst_list_asset_metadata {
14012 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14013 <wire_cst_asset_metadata>::new_with_null_ptr(),
14014 len,
14015 ),
14016 len,
14017 };
14018 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14019 }
14020
14021 #[unsafe(no_mangle)]
14022 pub extern "C" fn frbgen_breez_liquid_cst_new_list_external_input_parser(
14023 len: i32,
14024 ) -> *mut wire_cst_list_external_input_parser {
14025 let wrap = wire_cst_list_external_input_parser {
14026 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14027 <wire_cst_external_input_parser>::new_with_null_ptr(),
14028 len,
14029 ),
14030 len,
14031 };
14032 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14033 }
14034
14035 #[unsafe(no_mangle)]
14036 pub extern "C" fn frbgen_breez_liquid_cst_new_list_fiat_currency(
14037 len: i32,
14038 ) -> *mut wire_cst_list_fiat_currency {
14039 let wrap = wire_cst_list_fiat_currency {
14040 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14041 <wire_cst_fiat_currency>::new_with_null_ptr(),
14042 len,
14043 ),
14044 len,
14045 };
14046 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14047 }
14048
14049 #[unsafe(no_mangle)]
14050 pub extern "C" fn frbgen_breez_liquid_cst_new_list_ln_offer_blinded_path(
14051 len: i32,
14052 ) -> *mut wire_cst_list_ln_offer_blinded_path {
14053 let wrap = wire_cst_list_ln_offer_blinded_path {
14054 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14055 <wire_cst_ln_offer_blinded_path>::new_with_null_ptr(),
14056 len,
14057 ),
14058 len,
14059 };
14060 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14061 }
14062
14063 #[unsafe(no_mangle)]
14064 pub extern "C" fn frbgen_breez_liquid_cst_new_list_locale_overrides(
14065 len: i32,
14066 ) -> *mut wire_cst_list_locale_overrides {
14067 let wrap = wire_cst_list_locale_overrides {
14068 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14069 <wire_cst_locale_overrides>::new_with_null_ptr(),
14070 len,
14071 ),
14072 len,
14073 };
14074 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14075 }
14076
14077 #[unsafe(no_mangle)]
14078 pub extern "C" fn frbgen_breez_liquid_cst_new_list_localized_name(
14079 len: i32,
14080 ) -> *mut wire_cst_list_localized_name {
14081 let wrap = wire_cst_list_localized_name {
14082 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14083 <wire_cst_localized_name>::new_with_null_ptr(),
14084 len,
14085 ),
14086 len,
14087 };
14088 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14089 }
14090
14091 #[unsafe(no_mangle)]
14092 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment(
14093 len: i32,
14094 ) -> *mut wire_cst_list_payment {
14095 let wrap = wire_cst_list_payment {
14096 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14097 <wire_cst_payment>::new_with_null_ptr(),
14098 len,
14099 ),
14100 len,
14101 };
14102 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14103 }
14104
14105 #[unsafe(no_mangle)]
14106 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_state(
14107 len: i32,
14108 ) -> *mut wire_cst_list_payment_state {
14109 let wrap = wire_cst_list_payment_state {
14110 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14111 len,
14112 };
14113 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14114 }
14115
14116 #[unsafe(no_mangle)]
14117 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_type(
14118 len: i32,
14119 ) -> *mut wire_cst_list_payment_type {
14120 let wrap = wire_cst_list_payment_type {
14121 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14122 len,
14123 };
14124 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14125 }
14126
14127 #[unsafe(no_mangle)]
14128 pub extern "C" fn frbgen_breez_liquid_cst_new_list_prim_u_8_strict(
14129 len: i32,
14130 ) -> *mut wire_cst_list_prim_u_8_strict {
14131 let ans = wire_cst_list_prim_u_8_strict {
14132 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14133 len,
14134 };
14135 flutter_rust_bridge::for_generated::new_leak_box_ptr(ans)
14136 }
14137
14138 #[unsafe(no_mangle)]
14139 pub extern "C" fn frbgen_breez_liquid_cst_new_list_rate(len: i32) -> *mut wire_cst_list_rate {
14140 let wrap = wire_cst_list_rate {
14141 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14142 <wire_cst_rate>::new_with_null_ptr(),
14143 len,
14144 ),
14145 len,
14146 };
14147 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14148 }
14149
14150 #[unsafe(no_mangle)]
14151 pub extern "C" fn frbgen_breez_liquid_cst_new_list_refundable_swap(
14152 len: i32,
14153 ) -> *mut wire_cst_list_refundable_swap {
14154 let wrap = wire_cst_list_refundable_swap {
14155 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14156 <wire_cst_refundable_swap>::new_with_null_ptr(),
14157 len,
14158 ),
14159 len,
14160 };
14161 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14162 }
14163
14164 #[unsafe(no_mangle)]
14165 pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint(
14166 len: i32,
14167 ) -> *mut wire_cst_list_route_hint {
14168 let wrap = wire_cst_list_route_hint {
14169 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14170 <wire_cst_route_hint>::new_with_null_ptr(),
14171 len,
14172 ),
14173 len,
14174 };
14175 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14176 }
14177
14178 #[unsafe(no_mangle)]
14179 pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint_hop(
14180 len: i32,
14181 ) -> *mut wire_cst_list_route_hint_hop {
14182 let wrap = wire_cst_list_route_hint_hop {
14183 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14184 <wire_cst_route_hint_hop>::new_with_null_ptr(),
14185 len,
14186 ),
14187 len,
14188 };
14189 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14190 }
14191
14192 #[repr(C)]
14193 #[derive(Clone, Copy)]
14194 pub struct wire_cst_accept_payment_proposed_fees_request {
14195 response: wire_cst_fetch_payment_proposed_fees_response,
14196 }
14197 #[repr(C)]
14198 #[derive(Clone, Copy)]
14199 pub struct wire_cst_aes_success_action_data {
14200 description: *mut wire_cst_list_prim_u_8_strict,
14201 ciphertext: *mut wire_cst_list_prim_u_8_strict,
14202 iv: *mut wire_cst_list_prim_u_8_strict,
14203 }
14204 #[repr(C)]
14205 #[derive(Clone, Copy)]
14206 pub struct wire_cst_aes_success_action_data_decrypted {
14207 description: *mut wire_cst_list_prim_u_8_strict,
14208 plaintext: *mut wire_cst_list_prim_u_8_strict,
14209 }
14210 #[repr(C)]
14211 #[derive(Clone, Copy)]
14212 pub struct wire_cst_aes_success_action_data_result {
14213 tag: i32,
14214 kind: AesSuccessActionDataResultKind,
14215 }
14216 #[repr(C)]
14217 #[derive(Clone, Copy)]
14218 pub union AesSuccessActionDataResultKind {
14219 Decrypted: wire_cst_AesSuccessActionDataResult_Decrypted,
14220 ErrorStatus: wire_cst_AesSuccessActionDataResult_ErrorStatus,
14221 nil__: (),
14222 }
14223 #[repr(C)]
14224 #[derive(Clone, Copy)]
14225 pub struct wire_cst_AesSuccessActionDataResult_Decrypted {
14226 data: *mut wire_cst_aes_success_action_data_decrypted,
14227 }
14228 #[repr(C)]
14229 #[derive(Clone, Copy)]
14230 pub struct wire_cst_AesSuccessActionDataResult_ErrorStatus {
14231 reason: *mut wire_cst_list_prim_u_8_strict,
14232 }
14233 #[repr(C)]
14234 #[derive(Clone, Copy)]
14235 pub struct wire_cst_amount {
14236 tag: i32,
14237 kind: AmountKind,
14238 }
14239 #[repr(C)]
14240 #[derive(Clone, Copy)]
14241 pub union AmountKind {
14242 Bitcoin: wire_cst_Amount_Bitcoin,
14243 Currency: wire_cst_Amount_Currency,
14244 nil__: (),
14245 }
14246 #[repr(C)]
14247 #[derive(Clone, Copy)]
14248 pub struct wire_cst_Amount_Bitcoin {
14249 amount_msat: u64,
14250 }
14251 #[repr(C)]
14252 #[derive(Clone, Copy)]
14253 pub struct wire_cst_Amount_Currency {
14254 iso4217_code: *mut wire_cst_list_prim_u_8_strict,
14255 fractional_amount: u64,
14256 }
14257 #[repr(C)]
14258 #[derive(Clone, Copy)]
14259 pub struct wire_cst_asset_balance {
14260 asset_id: *mut wire_cst_list_prim_u_8_strict,
14261 balance_sat: u64,
14262 name: *mut wire_cst_list_prim_u_8_strict,
14263 ticker: *mut wire_cst_list_prim_u_8_strict,
14264 balance: *mut f64,
14265 }
14266 #[repr(C)]
14267 #[derive(Clone, Copy)]
14268 pub struct wire_cst_asset_info {
14269 name: *mut wire_cst_list_prim_u_8_strict,
14270 ticker: *mut wire_cst_list_prim_u_8_strict,
14271 amount: f64,
14272 fees: *mut f64,
14273 }
14274 #[repr(C)]
14275 #[derive(Clone, Copy)]
14276 pub struct wire_cst_asset_metadata {
14277 asset_id: *mut wire_cst_list_prim_u_8_strict,
14278 name: *mut wire_cst_list_prim_u_8_strict,
14279 ticker: *mut wire_cst_list_prim_u_8_strict,
14280 precision: u8,
14281 fiat_id: *mut wire_cst_list_prim_u_8_strict,
14282 }
14283 #[repr(C)]
14284 #[derive(Clone, Copy)]
14285 pub struct wire_cst_backup_request {
14286 backup_path: *mut wire_cst_list_prim_u_8_strict,
14287 }
14288 #[repr(C)]
14289 #[derive(Clone, Copy)]
14290 pub struct wire_cst_binding_event_listener {
14291 stream: *mut wire_cst_list_prim_u_8_strict,
14292 }
14293 #[repr(C)]
14294 #[derive(Clone, Copy)]
14295 pub struct wire_cst_bitcoin_address_data {
14296 address: *mut wire_cst_list_prim_u_8_strict,
14297 network: i32,
14298 amount_sat: *mut u64,
14299 label: *mut wire_cst_list_prim_u_8_strict,
14300 message: *mut wire_cst_list_prim_u_8_strict,
14301 }
14302 #[repr(C)]
14303 #[derive(Clone, Copy)]
14304 pub struct wire_cst_blockchain_explorer {
14305 tag: i32,
14306 kind: BlockchainExplorerKind,
14307 }
14308 #[repr(C)]
14309 #[derive(Clone, Copy)]
14310 pub union BlockchainExplorerKind {
14311 Electrum: wire_cst_BlockchainExplorer_Electrum,
14312 Esplora: wire_cst_BlockchainExplorer_Esplora,
14313 nil__: (),
14314 }
14315 #[repr(C)]
14316 #[derive(Clone, Copy)]
14317 pub struct wire_cst_BlockchainExplorer_Electrum {
14318 url: *mut wire_cst_list_prim_u_8_strict,
14319 }
14320 #[repr(C)]
14321 #[derive(Clone, Copy)]
14322 pub struct wire_cst_BlockchainExplorer_Esplora {
14323 url: *mut wire_cst_list_prim_u_8_strict,
14324 use_waterfalls: bool,
14325 }
14326 #[repr(C)]
14327 #[derive(Clone, Copy)]
14328 pub struct wire_cst_blockchain_info {
14329 liquid_tip: u32,
14330 bitcoin_tip: u32,
14331 }
14332 #[repr(C)]
14333 #[derive(Clone, Copy)]
14334 pub struct wire_cst_buy_bitcoin_request {
14335 prepare_response: wire_cst_prepare_buy_bitcoin_response,
14336 redirect_url: *mut wire_cst_list_prim_u_8_strict,
14337 }
14338 #[repr(C)]
14339 #[derive(Clone, Copy)]
14340 pub struct wire_cst_check_message_request {
14341 message: *mut wire_cst_list_prim_u_8_strict,
14342 pubkey: *mut wire_cst_list_prim_u_8_strict,
14343 signature: *mut wire_cst_list_prim_u_8_strict,
14344 }
14345 #[repr(C)]
14346 #[derive(Clone, Copy)]
14347 pub struct wire_cst_check_message_response {
14348 is_valid: bool,
14349 }
14350 #[repr(C)]
14351 #[derive(Clone, Copy)]
14352 pub struct wire_cst_config {
14353 liquid_explorer: wire_cst_blockchain_explorer,
14354 bitcoin_explorer: wire_cst_blockchain_explorer,
14355 working_dir: *mut wire_cst_list_prim_u_8_strict,
14356 network: i32,
14357 payment_timeout_sec: u64,
14358 sync_service_url: *mut wire_cst_list_prim_u_8_strict,
14359 zero_conf_max_amount_sat: *mut u64,
14360 breez_api_key: *mut wire_cst_list_prim_u_8_strict,
14361 external_input_parsers: *mut wire_cst_list_external_input_parser,
14362 use_default_external_input_parsers: bool,
14363 onchain_fee_rate_leeway_sat: *mut u64,
14364 asset_metadata: *mut wire_cst_list_asset_metadata,
14365 sideswap_api_key: *mut wire_cst_list_prim_u_8_strict,
14366 }
14367 #[repr(C)]
14368 #[derive(Clone, Copy)]
14369 pub struct wire_cst_connect_request {
14370 config: wire_cst_config,
14371 mnemonic: *mut wire_cst_list_prim_u_8_strict,
14372 passphrase: *mut wire_cst_list_prim_u_8_strict,
14373 seed: *mut wire_cst_list_prim_u_8_strict,
14374 }
14375 #[repr(C)]
14376 #[derive(Clone, Copy)]
14377 pub struct wire_cst_create_bolt_12_invoice_request {
14378 offer: *mut wire_cst_list_prim_u_8_strict,
14379 invoice_request: *mut wire_cst_list_prim_u_8_strict,
14380 }
14381 #[repr(C)]
14382 #[derive(Clone, Copy)]
14383 pub struct wire_cst_create_bolt_12_invoice_response {
14384 invoice: *mut wire_cst_list_prim_u_8_strict,
14385 }
14386 #[repr(C)]
14387 #[derive(Clone, Copy)]
14388 pub struct wire_cst_currency_info {
14389 name: *mut wire_cst_list_prim_u_8_strict,
14390 fraction_size: u32,
14391 spacing: *mut u32,
14392 symbol: *mut wire_cst_symbol,
14393 uniq_symbol: *mut wire_cst_symbol,
14394 localized_name: *mut wire_cst_list_localized_name,
14395 locale_overrides: *mut wire_cst_list_locale_overrides,
14396 }
14397 #[repr(C)]
14398 #[derive(Clone, Copy)]
14399 pub struct wire_cst_external_input_parser {
14400 provider_id: *mut wire_cst_list_prim_u_8_strict,
14401 input_regex: *mut wire_cst_list_prim_u_8_strict,
14402 parser_url: *mut wire_cst_list_prim_u_8_strict,
14403 }
14404 #[repr(C)]
14405 #[derive(Clone, Copy)]
14406 pub struct wire_cst_fetch_payment_proposed_fees_request {
14407 swap_id: *mut wire_cst_list_prim_u_8_strict,
14408 }
14409 #[repr(C)]
14410 #[derive(Clone, Copy)]
14411 pub struct wire_cst_fetch_payment_proposed_fees_response {
14412 swap_id: *mut wire_cst_list_prim_u_8_strict,
14413 fees_sat: u64,
14414 payer_amount_sat: u64,
14415 receiver_amount_sat: u64,
14416 }
14417 #[repr(C)]
14418 #[derive(Clone, Copy)]
14419 pub struct wire_cst_fiat_currency {
14420 id: *mut wire_cst_list_prim_u_8_strict,
14421 info: wire_cst_currency_info,
14422 }
14423 #[repr(C)]
14424 #[derive(Clone, Copy)]
14425 pub struct wire_cst_get_info_response {
14426 wallet_info: wire_cst_wallet_info,
14427 blockchain_info: wire_cst_blockchain_info,
14428 }
14429 #[repr(C)]
14430 #[derive(Clone, Copy)]
14431 pub struct wire_cst_get_payment_request {
14432 tag: i32,
14433 kind: GetPaymentRequestKind,
14434 }
14435 #[repr(C)]
14436 #[derive(Clone, Copy)]
14437 pub union GetPaymentRequestKind {
14438 PaymentHash: wire_cst_GetPaymentRequest_PaymentHash,
14439 SwapId: wire_cst_GetPaymentRequest_SwapId,
14440 nil__: (),
14441 }
14442 #[repr(C)]
14443 #[derive(Clone, Copy)]
14444 pub struct wire_cst_GetPaymentRequest_PaymentHash {
14445 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14446 }
14447 #[repr(C)]
14448 #[derive(Clone, Copy)]
14449 pub struct wire_cst_GetPaymentRequest_SwapId {
14450 swap_id: *mut wire_cst_list_prim_u_8_strict,
14451 }
14452 #[repr(C)]
14453 #[derive(Clone, Copy)]
14454 pub struct wire_cst_input_type {
14455 tag: i32,
14456 kind: InputTypeKind,
14457 }
14458 #[repr(C)]
14459 #[derive(Clone, Copy)]
14460 pub union InputTypeKind {
14461 BitcoinAddress: wire_cst_InputType_BitcoinAddress,
14462 LiquidAddress: wire_cst_InputType_LiquidAddress,
14463 Bolt11: wire_cst_InputType_Bolt11,
14464 Bolt12Offer: wire_cst_InputType_Bolt12Offer,
14465 NodeId: wire_cst_InputType_NodeId,
14466 Url: wire_cst_InputType_Url,
14467 LnUrlPay: wire_cst_InputType_LnUrlPay,
14468 LnUrlWithdraw: wire_cst_InputType_LnUrlWithdraw,
14469 LnUrlAuth: wire_cst_InputType_LnUrlAuth,
14470 LnUrlError: wire_cst_InputType_LnUrlError,
14471 nil__: (),
14472 }
14473 #[repr(C)]
14474 #[derive(Clone, Copy)]
14475 pub struct wire_cst_InputType_BitcoinAddress {
14476 address: *mut wire_cst_bitcoin_address_data,
14477 }
14478 #[repr(C)]
14479 #[derive(Clone, Copy)]
14480 pub struct wire_cst_InputType_LiquidAddress {
14481 address: *mut wire_cst_liquid_address_data,
14482 }
14483 #[repr(C)]
14484 #[derive(Clone, Copy)]
14485 pub struct wire_cst_InputType_Bolt11 {
14486 invoice: *mut wire_cst_ln_invoice,
14487 }
14488 #[repr(C)]
14489 #[derive(Clone, Copy)]
14490 pub struct wire_cst_InputType_Bolt12Offer {
14491 offer: *mut wire_cst_ln_offer,
14492 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14493 }
14494 #[repr(C)]
14495 #[derive(Clone, Copy)]
14496 pub struct wire_cst_InputType_NodeId {
14497 node_id: *mut wire_cst_list_prim_u_8_strict,
14498 }
14499 #[repr(C)]
14500 #[derive(Clone, Copy)]
14501 pub struct wire_cst_InputType_Url {
14502 url: *mut wire_cst_list_prim_u_8_strict,
14503 }
14504 #[repr(C)]
14505 #[derive(Clone, Copy)]
14506 pub struct wire_cst_InputType_LnUrlPay {
14507 data: *mut wire_cst_ln_url_pay_request_data,
14508 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14509 }
14510 #[repr(C)]
14511 #[derive(Clone, Copy)]
14512 pub struct wire_cst_InputType_LnUrlWithdraw {
14513 data: *mut wire_cst_ln_url_withdraw_request_data,
14514 }
14515 #[repr(C)]
14516 #[derive(Clone, Copy)]
14517 pub struct wire_cst_InputType_LnUrlAuth {
14518 data: *mut wire_cst_ln_url_auth_request_data,
14519 }
14520 #[repr(C)]
14521 #[derive(Clone, Copy)]
14522 pub struct wire_cst_InputType_LnUrlError {
14523 data: *mut wire_cst_ln_url_error_data,
14524 }
14525 #[repr(C)]
14526 #[derive(Clone, Copy)]
14527 pub struct wire_cst_lightning_payment_limits_response {
14528 send: wire_cst_limits,
14529 receive: wire_cst_limits,
14530 }
14531 #[repr(C)]
14532 #[derive(Clone, Copy)]
14533 pub struct wire_cst_limits {
14534 min_sat: u64,
14535 max_sat: u64,
14536 max_zero_conf_sat: u64,
14537 }
14538 #[repr(C)]
14539 #[derive(Clone, Copy)]
14540 pub struct wire_cst_liquid_address_data {
14541 address: *mut wire_cst_list_prim_u_8_strict,
14542 network: i32,
14543 asset_id: *mut wire_cst_list_prim_u_8_strict,
14544 amount: *mut f64,
14545 amount_sat: *mut u64,
14546 label: *mut wire_cst_list_prim_u_8_strict,
14547 message: *mut wire_cst_list_prim_u_8_strict,
14548 }
14549 #[repr(C)]
14550 #[derive(Clone, Copy)]
14551 pub struct wire_cst_list_String {
14552 ptr: *mut *mut wire_cst_list_prim_u_8_strict,
14553 len: i32,
14554 }
14555 #[repr(C)]
14556 #[derive(Clone, Copy)]
14557 pub struct wire_cst_list_asset_balance {
14558 ptr: *mut wire_cst_asset_balance,
14559 len: i32,
14560 }
14561 #[repr(C)]
14562 #[derive(Clone, Copy)]
14563 pub struct wire_cst_list_asset_metadata {
14564 ptr: *mut wire_cst_asset_metadata,
14565 len: i32,
14566 }
14567 #[repr(C)]
14568 #[derive(Clone, Copy)]
14569 pub struct wire_cst_list_external_input_parser {
14570 ptr: *mut wire_cst_external_input_parser,
14571 len: i32,
14572 }
14573 #[repr(C)]
14574 #[derive(Clone, Copy)]
14575 pub struct wire_cst_list_fiat_currency {
14576 ptr: *mut wire_cst_fiat_currency,
14577 len: i32,
14578 }
14579 #[repr(C)]
14580 #[derive(Clone, Copy)]
14581 pub struct wire_cst_list_ln_offer_blinded_path {
14582 ptr: *mut wire_cst_ln_offer_blinded_path,
14583 len: i32,
14584 }
14585 #[repr(C)]
14586 #[derive(Clone, Copy)]
14587 pub struct wire_cst_list_locale_overrides {
14588 ptr: *mut wire_cst_locale_overrides,
14589 len: i32,
14590 }
14591 #[repr(C)]
14592 #[derive(Clone, Copy)]
14593 pub struct wire_cst_list_localized_name {
14594 ptr: *mut wire_cst_localized_name,
14595 len: i32,
14596 }
14597 #[repr(C)]
14598 #[derive(Clone, Copy)]
14599 pub struct wire_cst_list_payment {
14600 ptr: *mut wire_cst_payment,
14601 len: i32,
14602 }
14603 #[repr(C)]
14604 #[derive(Clone, Copy)]
14605 pub struct wire_cst_list_payment_details {
14606 tag: i32,
14607 kind: ListPaymentDetailsKind,
14608 }
14609 #[repr(C)]
14610 #[derive(Clone, Copy)]
14611 pub union ListPaymentDetailsKind {
14612 Liquid: wire_cst_ListPaymentDetails_Liquid,
14613 Bitcoin: wire_cst_ListPaymentDetails_Bitcoin,
14614 nil__: (),
14615 }
14616 #[repr(C)]
14617 #[derive(Clone, Copy)]
14618 pub struct wire_cst_ListPaymentDetails_Liquid {
14619 asset_id: *mut wire_cst_list_prim_u_8_strict,
14620 destination: *mut wire_cst_list_prim_u_8_strict,
14621 }
14622 #[repr(C)]
14623 #[derive(Clone, Copy)]
14624 pub struct wire_cst_ListPaymentDetails_Bitcoin {
14625 address: *mut wire_cst_list_prim_u_8_strict,
14626 }
14627 #[repr(C)]
14628 #[derive(Clone, Copy)]
14629 pub struct wire_cst_list_payment_state {
14630 ptr: *mut i32,
14631 len: i32,
14632 }
14633 #[repr(C)]
14634 #[derive(Clone, Copy)]
14635 pub struct wire_cst_list_payment_type {
14636 ptr: *mut i32,
14637 len: i32,
14638 }
14639 #[repr(C)]
14640 #[derive(Clone, Copy)]
14641 pub struct wire_cst_list_payments_request {
14642 filters: *mut wire_cst_list_payment_type,
14643 states: *mut wire_cst_list_payment_state,
14644 from_timestamp: *mut i64,
14645 to_timestamp: *mut i64,
14646 offset: *mut u32,
14647 limit: *mut u32,
14648 details: *mut wire_cst_list_payment_details,
14649 sort_ascending: *mut bool,
14650 }
14651 #[repr(C)]
14652 #[derive(Clone, Copy)]
14653 pub struct wire_cst_list_prim_u_8_strict {
14654 ptr: *mut u8,
14655 len: i32,
14656 }
14657 #[repr(C)]
14658 #[derive(Clone, Copy)]
14659 pub struct wire_cst_list_rate {
14660 ptr: *mut wire_cst_rate,
14661 len: i32,
14662 }
14663 #[repr(C)]
14664 #[derive(Clone, Copy)]
14665 pub struct wire_cst_list_refundable_swap {
14666 ptr: *mut wire_cst_refundable_swap,
14667 len: i32,
14668 }
14669 #[repr(C)]
14670 #[derive(Clone, Copy)]
14671 pub struct wire_cst_list_route_hint {
14672 ptr: *mut wire_cst_route_hint,
14673 len: i32,
14674 }
14675 #[repr(C)]
14676 #[derive(Clone, Copy)]
14677 pub struct wire_cst_list_route_hint_hop {
14678 ptr: *mut wire_cst_route_hint_hop,
14679 len: i32,
14680 }
14681 #[repr(C)]
14682 #[derive(Clone, Copy)]
14683 pub struct wire_cst_ln_invoice {
14684 bolt11: *mut wire_cst_list_prim_u_8_strict,
14685 network: i32,
14686 payee_pubkey: *mut wire_cst_list_prim_u_8_strict,
14687 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14688 description: *mut wire_cst_list_prim_u_8_strict,
14689 description_hash: *mut wire_cst_list_prim_u_8_strict,
14690 amount_msat: *mut u64,
14691 timestamp: u64,
14692 expiry: u64,
14693 routing_hints: *mut wire_cst_list_route_hint,
14694 payment_secret: *mut wire_cst_list_prim_u_8_strict,
14695 min_final_cltv_expiry_delta: u64,
14696 }
14697 #[repr(C)]
14698 #[derive(Clone, Copy)]
14699 pub struct wire_cst_ln_offer {
14700 offer: *mut wire_cst_list_prim_u_8_strict,
14701 chains: *mut wire_cst_list_String,
14702 min_amount: *mut wire_cst_amount,
14703 description: *mut wire_cst_list_prim_u_8_strict,
14704 absolute_expiry: *mut u64,
14705 issuer: *mut wire_cst_list_prim_u_8_strict,
14706 signing_pubkey: *mut wire_cst_list_prim_u_8_strict,
14707 paths: *mut wire_cst_list_ln_offer_blinded_path,
14708 }
14709 #[repr(C)]
14710 #[derive(Clone, Copy)]
14711 pub struct wire_cst_ln_offer_blinded_path {
14712 blinded_hops: *mut wire_cst_list_String,
14713 }
14714 #[repr(C)]
14715 #[derive(Clone, Copy)]
14716 pub struct wire_cst_ln_url_auth_error {
14717 tag: i32,
14718 kind: LnUrlAuthErrorKind,
14719 }
14720 #[repr(C)]
14721 #[derive(Clone, Copy)]
14722 pub union LnUrlAuthErrorKind {
14723 Generic: wire_cst_LnUrlAuthError_Generic,
14724 InvalidUri: wire_cst_LnUrlAuthError_InvalidUri,
14725 ServiceConnectivity: wire_cst_LnUrlAuthError_ServiceConnectivity,
14726 nil__: (),
14727 }
14728 #[repr(C)]
14729 #[derive(Clone, Copy)]
14730 pub struct wire_cst_LnUrlAuthError_Generic {
14731 err: *mut wire_cst_list_prim_u_8_strict,
14732 }
14733 #[repr(C)]
14734 #[derive(Clone, Copy)]
14735 pub struct wire_cst_LnUrlAuthError_InvalidUri {
14736 err: *mut wire_cst_list_prim_u_8_strict,
14737 }
14738 #[repr(C)]
14739 #[derive(Clone, Copy)]
14740 pub struct wire_cst_LnUrlAuthError_ServiceConnectivity {
14741 err: *mut wire_cst_list_prim_u_8_strict,
14742 }
14743 #[repr(C)]
14744 #[derive(Clone, Copy)]
14745 pub struct wire_cst_ln_url_auth_request_data {
14746 k1: *mut wire_cst_list_prim_u_8_strict,
14747 action: *mut wire_cst_list_prim_u_8_strict,
14748 domain: *mut wire_cst_list_prim_u_8_strict,
14749 url: *mut wire_cst_list_prim_u_8_strict,
14750 }
14751 #[repr(C)]
14752 #[derive(Clone, Copy)]
14753 pub struct wire_cst_ln_url_callback_status {
14754 tag: i32,
14755 kind: LnUrlCallbackStatusKind,
14756 }
14757 #[repr(C)]
14758 #[derive(Clone, Copy)]
14759 pub union LnUrlCallbackStatusKind {
14760 ErrorStatus: wire_cst_LnUrlCallbackStatus_ErrorStatus,
14761 nil__: (),
14762 }
14763 #[repr(C)]
14764 #[derive(Clone, Copy)]
14765 pub struct wire_cst_LnUrlCallbackStatus_ErrorStatus {
14766 data: *mut wire_cst_ln_url_error_data,
14767 }
14768 #[repr(C)]
14769 #[derive(Clone, Copy)]
14770 pub struct wire_cst_ln_url_error_data {
14771 reason: *mut wire_cst_list_prim_u_8_strict,
14772 }
14773 #[repr(C)]
14774 #[derive(Clone, Copy)]
14775 pub struct wire_cst_ln_url_info {
14776 ln_address: *mut wire_cst_list_prim_u_8_strict,
14777 lnurl_pay_comment: *mut wire_cst_list_prim_u_8_strict,
14778 lnurl_pay_domain: *mut wire_cst_list_prim_u_8_strict,
14779 lnurl_pay_metadata: *mut wire_cst_list_prim_u_8_strict,
14780 lnurl_pay_success_action: *mut wire_cst_success_action_processed,
14781 lnurl_pay_unprocessed_success_action: *mut wire_cst_success_action,
14782 lnurl_withdraw_endpoint: *mut wire_cst_list_prim_u_8_strict,
14783 }
14784 #[repr(C)]
14785 #[derive(Clone, Copy)]
14786 pub struct wire_cst_ln_url_pay_error {
14787 tag: i32,
14788 kind: LnUrlPayErrorKind,
14789 }
14790 #[repr(C)]
14791 #[derive(Clone, Copy)]
14792 pub union LnUrlPayErrorKind {
14793 Generic: wire_cst_LnUrlPayError_Generic,
14794 InsufficientBalance: wire_cst_LnUrlPayError_InsufficientBalance,
14795 InvalidAmount: wire_cst_LnUrlPayError_InvalidAmount,
14796 InvalidInvoice: wire_cst_LnUrlPayError_InvalidInvoice,
14797 InvalidNetwork: wire_cst_LnUrlPayError_InvalidNetwork,
14798 InvalidUri: wire_cst_LnUrlPayError_InvalidUri,
14799 InvoiceExpired: wire_cst_LnUrlPayError_InvoiceExpired,
14800 PaymentFailed: wire_cst_LnUrlPayError_PaymentFailed,
14801 PaymentTimeout: wire_cst_LnUrlPayError_PaymentTimeout,
14802 RouteNotFound: wire_cst_LnUrlPayError_RouteNotFound,
14803 RouteTooExpensive: wire_cst_LnUrlPayError_RouteTooExpensive,
14804 ServiceConnectivity: wire_cst_LnUrlPayError_ServiceConnectivity,
14805 nil__: (),
14806 }
14807 #[repr(C)]
14808 #[derive(Clone, Copy)]
14809 pub struct wire_cst_LnUrlPayError_Generic {
14810 err: *mut wire_cst_list_prim_u_8_strict,
14811 }
14812 #[repr(C)]
14813 #[derive(Clone, Copy)]
14814 pub struct wire_cst_LnUrlPayError_InsufficientBalance {
14815 err: *mut wire_cst_list_prim_u_8_strict,
14816 }
14817 #[repr(C)]
14818 #[derive(Clone, Copy)]
14819 pub struct wire_cst_LnUrlPayError_InvalidAmount {
14820 err: *mut wire_cst_list_prim_u_8_strict,
14821 }
14822 #[repr(C)]
14823 #[derive(Clone, Copy)]
14824 pub struct wire_cst_LnUrlPayError_InvalidInvoice {
14825 err: *mut wire_cst_list_prim_u_8_strict,
14826 }
14827 #[repr(C)]
14828 #[derive(Clone, Copy)]
14829 pub struct wire_cst_LnUrlPayError_InvalidNetwork {
14830 err: *mut wire_cst_list_prim_u_8_strict,
14831 }
14832 #[repr(C)]
14833 #[derive(Clone, Copy)]
14834 pub struct wire_cst_LnUrlPayError_InvalidUri {
14835 err: *mut wire_cst_list_prim_u_8_strict,
14836 }
14837 #[repr(C)]
14838 #[derive(Clone, Copy)]
14839 pub struct wire_cst_LnUrlPayError_InvoiceExpired {
14840 err: *mut wire_cst_list_prim_u_8_strict,
14841 }
14842 #[repr(C)]
14843 #[derive(Clone, Copy)]
14844 pub struct wire_cst_LnUrlPayError_PaymentFailed {
14845 err: *mut wire_cst_list_prim_u_8_strict,
14846 }
14847 #[repr(C)]
14848 #[derive(Clone, Copy)]
14849 pub struct wire_cst_LnUrlPayError_PaymentTimeout {
14850 err: *mut wire_cst_list_prim_u_8_strict,
14851 }
14852 #[repr(C)]
14853 #[derive(Clone, Copy)]
14854 pub struct wire_cst_LnUrlPayError_RouteNotFound {
14855 err: *mut wire_cst_list_prim_u_8_strict,
14856 }
14857 #[repr(C)]
14858 #[derive(Clone, Copy)]
14859 pub struct wire_cst_LnUrlPayError_RouteTooExpensive {
14860 err: *mut wire_cst_list_prim_u_8_strict,
14861 }
14862 #[repr(C)]
14863 #[derive(Clone, Copy)]
14864 pub struct wire_cst_LnUrlPayError_ServiceConnectivity {
14865 err: *mut wire_cst_list_prim_u_8_strict,
14866 }
14867 #[repr(C)]
14868 #[derive(Clone, Copy)]
14869 pub struct wire_cst_ln_url_pay_error_data {
14870 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14871 reason: *mut wire_cst_list_prim_u_8_strict,
14872 }
14873 #[repr(C)]
14874 #[derive(Clone, Copy)]
14875 pub struct wire_cst_ln_url_pay_request {
14876 prepare_response: wire_cst_prepare_ln_url_pay_response,
14877 }
14878 #[repr(C)]
14879 #[derive(Clone, Copy)]
14880 pub struct wire_cst_ln_url_pay_request_data {
14881 callback: *mut wire_cst_list_prim_u_8_strict,
14882 min_sendable: u64,
14883 max_sendable: u64,
14884 metadata_str: *mut wire_cst_list_prim_u_8_strict,
14885 comment_allowed: u16,
14886 domain: *mut wire_cst_list_prim_u_8_strict,
14887 allows_nostr: bool,
14888 nostr_pubkey: *mut wire_cst_list_prim_u_8_strict,
14889 ln_address: *mut wire_cst_list_prim_u_8_strict,
14890 }
14891 #[repr(C)]
14892 #[derive(Clone, Copy)]
14893 pub struct wire_cst_ln_url_pay_result {
14894 tag: i32,
14895 kind: LnUrlPayResultKind,
14896 }
14897 #[repr(C)]
14898 #[derive(Clone, Copy)]
14899 pub union LnUrlPayResultKind {
14900 EndpointSuccess: wire_cst_LnUrlPayResult_EndpointSuccess,
14901 EndpointError: wire_cst_LnUrlPayResult_EndpointError,
14902 PayError: wire_cst_LnUrlPayResult_PayError,
14903 nil__: (),
14904 }
14905 #[repr(C)]
14906 #[derive(Clone, Copy)]
14907 pub struct wire_cst_LnUrlPayResult_EndpointSuccess {
14908 data: *mut wire_cst_ln_url_pay_success_data,
14909 }
14910 #[repr(C)]
14911 #[derive(Clone, Copy)]
14912 pub struct wire_cst_LnUrlPayResult_EndpointError {
14913 data: *mut wire_cst_ln_url_error_data,
14914 }
14915 #[repr(C)]
14916 #[derive(Clone, Copy)]
14917 pub struct wire_cst_LnUrlPayResult_PayError {
14918 data: *mut wire_cst_ln_url_pay_error_data,
14919 }
14920 #[repr(C)]
14921 #[derive(Clone, Copy)]
14922 pub struct wire_cst_ln_url_pay_success_data {
14923 payment: wire_cst_payment,
14924 success_action: *mut wire_cst_success_action_processed,
14925 }
14926 #[repr(C)]
14927 #[derive(Clone, Copy)]
14928 pub struct wire_cst_ln_url_withdraw_error {
14929 tag: i32,
14930 kind: LnUrlWithdrawErrorKind,
14931 }
14932 #[repr(C)]
14933 #[derive(Clone, Copy)]
14934 pub union LnUrlWithdrawErrorKind {
14935 Generic: wire_cst_LnUrlWithdrawError_Generic,
14936 InvalidAmount: wire_cst_LnUrlWithdrawError_InvalidAmount,
14937 InvalidInvoice: wire_cst_LnUrlWithdrawError_InvalidInvoice,
14938 InvalidUri: wire_cst_LnUrlWithdrawError_InvalidUri,
14939 InvoiceNoRoutingHints: wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints,
14940 ServiceConnectivity: wire_cst_LnUrlWithdrawError_ServiceConnectivity,
14941 nil__: (),
14942 }
14943 #[repr(C)]
14944 #[derive(Clone, Copy)]
14945 pub struct wire_cst_LnUrlWithdrawError_Generic {
14946 err: *mut wire_cst_list_prim_u_8_strict,
14947 }
14948 #[repr(C)]
14949 #[derive(Clone, Copy)]
14950 pub struct wire_cst_LnUrlWithdrawError_InvalidAmount {
14951 err: *mut wire_cst_list_prim_u_8_strict,
14952 }
14953 #[repr(C)]
14954 #[derive(Clone, Copy)]
14955 pub struct wire_cst_LnUrlWithdrawError_InvalidInvoice {
14956 err: *mut wire_cst_list_prim_u_8_strict,
14957 }
14958 #[repr(C)]
14959 #[derive(Clone, Copy)]
14960 pub struct wire_cst_LnUrlWithdrawError_InvalidUri {
14961 err: *mut wire_cst_list_prim_u_8_strict,
14962 }
14963 #[repr(C)]
14964 #[derive(Clone, Copy)]
14965 pub struct wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints {
14966 err: *mut wire_cst_list_prim_u_8_strict,
14967 }
14968 #[repr(C)]
14969 #[derive(Clone, Copy)]
14970 pub struct wire_cst_LnUrlWithdrawError_ServiceConnectivity {
14971 err: *mut wire_cst_list_prim_u_8_strict,
14972 }
14973 #[repr(C)]
14974 #[derive(Clone, Copy)]
14975 pub struct wire_cst_ln_url_withdraw_request {
14976 data: wire_cst_ln_url_withdraw_request_data,
14977 amount_msat: u64,
14978 description: *mut wire_cst_list_prim_u_8_strict,
14979 }
14980 #[repr(C)]
14981 #[derive(Clone, Copy)]
14982 pub struct wire_cst_ln_url_withdraw_request_data {
14983 callback: *mut wire_cst_list_prim_u_8_strict,
14984 k1: *mut wire_cst_list_prim_u_8_strict,
14985 default_description: *mut wire_cst_list_prim_u_8_strict,
14986 min_withdrawable: u64,
14987 max_withdrawable: u64,
14988 }
14989 #[repr(C)]
14990 #[derive(Clone, Copy)]
14991 pub struct wire_cst_ln_url_withdraw_result {
14992 tag: i32,
14993 kind: LnUrlWithdrawResultKind,
14994 }
14995 #[repr(C)]
14996 #[derive(Clone, Copy)]
14997 pub union LnUrlWithdrawResultKind {
14998 Ok: wire_cst_LnUrlWithdrawResult_Ok,
14999 Timeout: wire_cst_LnUrlWithdrawResult_Timeout,
15000 ErrorStatus: wire_cst_LnUrlWithdrawResult_ErrorStatus,
15001 nil__: (),
15002 }
15003 #[repr(C)]
15004 #[derive(Clone, Copy)]
15005 pub struct wire_cst_LnUrlWithdrawResult_Ok {
15006 data: *mut wire_cst_ln_url_withdraw_success_data,
15007 }
15008 #[repr(C)]
15009 #[derive(Clone, Copy)]
15010 pub struct wire_cst_LnUrlWithdrawResult_Timeout {
15011 data: *mut wire_cst_ln_url_withdraw_success_data,
15012 }
15013 #[repr(C)]
15014 #[derive(Clone, Copy)]
15015 pub struct wire_cst_LnUrlWithdrawResult_ErrorStatus {
15016 data: *mut wire_cst_ln_url_error_data,
15017 }
15018 #[repr(C)]
15019 #[derive(Clone, Copy)]
15020 pub struct wire_cst_ln_url_withdraw_success_data {
15021 invoice: wire_cst_ln_invoice,
15022 }
15023 #[repr(C)]
15024 #[derive(Clone, Copy)]
15025 pub struct wire_cst_locale_overrides {
15026 locale: *mut wire_cst_list_prim_u_8_strict,
15027 spacing: *mut u32,
15028 symbol: wire_cst_symbol,
15029 }
15030 #[repr(C)]
15031 #[derive(Clone, Copy)]
15032 pub struct wire_cst_localized_name {
15033 locale: *mut wire_cst_list_prim_u_8_strict,
15034 name: *mut wire_cst_list_prim_u_8_strict,
15035 }
15036 #[repr(C)]
15037 #[derive(Clone, Copy)]
15038 pub struct wire_cst_log_entry {
15039 line: *mut wire_cst_list_prim_u_8_strict,
15040 level: *mut wire_cst_list_prim_u_8_strict,
15041 }
15042 #[repr(C)]
15043 #[derive(Clone, Copy)]
15044 pub struct wire_cst_message_success_action_data {
15045 message: *mut wire_cst_list_prim_u_8_strict,
15046 }
15047 #[repr(C)]
15048 #[derive(Clone, Copy)]
15049 pub struct wire_cst_onchain_payment_limits_response {
15050 send: wire_cst_limits,
15051 receive: wire_cst_limits,
15052 }
15053 #[repr(C)]
15054 #[derive(Clone, Copy)]
15055 pub struct wire_cst_pay_amount {
15056 tag: i32,
15057 kind: PayAmountKind,
15058 }
15059 #[repr(C)]
15060 #[derive(Clone, Copy)]
15061 pub union PayAmountKind {
15062 Bitcoin: wire_cst_PayAmount_Bitcoin,
15063 Asset: wire_cst_PayAmount_Asset,
15064 nil__: (),
15065 }
15066 #[repr(C)]
15067 #[derive(Clone, Copy)]
15068 pub struct wire_cst_PayAmount_Bitcoin {
15069 receiver_amount_sat: u64,
15070 }
15071 #[repr(C)]
15072 #[derive(Clone, Copy)]
15073 pub struct wire_cst_PayAmount_Asset {
15074 asset_id: *mut wire_cst_list_prim_u_8_strict,
15075 receiver_amount: f64,
15076 estimate_asset_fees: *mut bool,
15077 pay_with_bitcoin: *mut bool,
15078 }
15079 #[repr(C)]
15080 #[derive(Clone, Copy)]
15081 pub struct wire_cst_pay_onchain_request {
15082 address: *mut wire_cst_list_prim_u_8_strict,
15083 prepare_response: wire_cst_prepare_pay_onchain_response,
15084 }
15085 #[repr(C)]
15086 #[derive(Clone, Copy)]
15087 pub struct wire_cst_payment {
15088 destination: *mut wire_cst_list_prim_u_8_strict,
15089 tx_id: *mut wire_cst_list_prim_u_8_strict,
15090 unblinding_data: *mut wire_cst_list_prim_u_8_strict,
15091 timestamp: u32,
15092 amount_sat: u64,
15093 fees_sat: u64,
15094 swapper_fees_sat: *mut u64,
15095 payment_type: i32,
15096 status: i32,
15097 details: wire_cst_payment_details,
15098 }
15099 #[repr(C)]
15100 #[derive(Clone, Copy)]
15101 pub struct wire_cst_payment_details {
15102 tag: i32,
15103 kind: PaymentDetailsKind,
15104 }
15105 #[repr(C)]
15106 #[derive(Clone, Copy)]
15107 pub union PaymentDetailsKind {
15108 Lightning: wire_cst_PaymentDetails_Lightning,
15109 Liquid: wire_cst_PaymentDetails_Liquid,
15110 Bitcoin: wire_cst_PaymentDetails_Bitcoin,
15111 nil__: (),
15112 }
15113 #[repr(C)]
15114 #[derive(Clone, Copy)]
15115 pub struct wire_cst_PaymentDetails_Lightning {
15116 swap_id: *mut wire_cst_list_prim_u_8_strict,
15117 description: *mut wire_cst_list_prim_u_8_strict,
15118 liquid_expiration_blockheight: u32,
15119 preimage: *mut wire_cst_list_prim_u_8_strict,
15120 invoice: *mut wire_cst_list_prim_u_8_strict,
15121 bolt12_offer: *mut wire_cst_list_prim_u_8_strict,
15122 payment_hash: *mut wire_cst_list_prim_u_8_strict,
15123 destination_pubkey: *mut wire_cst_list_prim_u_8_strict,
15124 lnurl_info: *mut wire_cst_ln_url_info,
15125 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15126 payer_note: *mut wire_cst_list_prim_u_8_strict,
15127 claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15128 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15129 refund_tx_amount_sat: *mut u64,
15130 }
15131 #[repr(C)]
15132 #[derive(Clone, Copy)]
15133 pub struct wire_cst_PaymentDetails_Liquid {
15134 destination: *mut wire_cst_list_prim_u_8_strict,
15135 description: *mut wire_cst_list_prim_u_8_strict,
15136 asset_id: *mut wire_cst_list_prim_u_8_strict,
15137 asset_info: *mut wire_cst_asset_info,
15138 lnurl_info: *mut wire_cst_ln_url_info,
15139 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15140 payer_note: *mut wire_cst_list_prim_u_8_strict,
15141 }
15142 #[repr(C)]
15143 #[derive(Clone, Copy)]
15144 pub struct wire_cst_PaymentDetails_Bitcoin {
15145 swap_id: *mut wire_cst_list_prim_u_8_strict,
15146 bitcoin_address: *mut wire_cst_list_prim_u_8_strict,
15147 description: *mut wire_cst_list_prim_u_8_strict,
15148 auto_accepted_fees: bool,
15149 liquid_expiration_blockheight: *mut u32,
15150 bitcoin_expiration_blockheight: *mut u32,
15151 lockup_tx_id: *mut wire_cst_list_prim_u_8_strict,
15152 claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15153 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15154 refund_tx_amount_sat: *mut u64,
15155 }
15156 #[repr(C)]
15157 #[derive(Clone, Copy)]
15158 pub struct wire_cst_payment_error {
15159 tag: i32,
15160 kind: PaymentErrorKind,
15161 }
15162 #[repr(C)]
15163 #[derive(Clone, Copy)]
15164 pub union PaymentErrorKind {
15165 AmountOutOfRange: wire_cst_PaymentError_AmountOutOfRange,
15166 AmountMissing: wire_cst_PaymentError_AmountMissing,
15167 AssetError: wire_cst_PaymentError_AssetError,
15168 InvalidNetwork: wire_cst_PaymentError_InvalidNetwork,
15169 Generic: wire_cst_PaymentError_Generic,
15170 InvalidDescription: wire_cst_PaymentError_InvalidDescription,
15171 InvalidInvoice: wire_cst_PaymentError_InvalidInvoice,
15172 ReceiveError: wire_cst_PaymentError_ReceiveError,
15173 Refunded: wire_cst_PaymentError_Refunded,
15174 SendError: wire_cst_PaymentError_SendError,
15175 SignerError: wire_cst_PaymentError_SignerError,
15176 nil__: (),
15177 }
15178 #[repr(C)]
15179 #[derive(Clone, Copy)]
15180 pub struct wire_cst_PaymentError_AmountOutOfRange {
15181 min: u64,
15182 max: u64,
15183 }
15184 #[repr(C)]
15185 #[derive(Clone, Copy)]
15186 pub struct wire_cst_PaymentError_AmountMissing {
15187 err: *mut wire_cst_list_prim_u_8_strict,
15188 }
15189 #[repr(C)]
15190 #[derive(Clone, Copy)]
15191 pub struct wire_cst_PaymentError_AssetError {
15192 err: *mut wire_cst_list_prim_u_8_strict,
15193 }
15194 #[repr(C)]
15195 #[derive(Clone, Copy)]
15196 pub struct wire_cst_PaymentError_InvalidNetwork {
15197 err: *mut wire_cst_list_prim_u_8_strict,
15198 }
15199 #[repr(C)]
15200 #[derive(Clone, Copy)]
15201 pub struct wire_cst_PaymentError_Generic {
15202 err: *mut wire_cst_list_prim_u_8_strict,
15203 }
15204 #[repr(C)]
15205 #[derive(Clone, Copy)]
15206 pub struct wire_cst_PaymentError_InvalidDescription {
15207 err: *mut wire_cst_list_prim_u_8_strict,
15208 }
15209 #[repr(C)]
15210 #[derive(Clone, Copy)]
15211 pub struct wire_cst_PaymentError_InvalidInvoice {
15212 err: *mut wire_cst_list_prim_u_8_strict,
15213 }
15214 #[repr(C)]
15215 #[derive(Clone, Copy)]
15216 pub struct wire_cst_PaymentError_ReceiveError {
15217 err: *mut wire_cst_list_prim_u_8_strict,
15218 }
15219 #[repr(C)]
15220 #[derive(Clone, Copy)]
15221 pub struct wire_cst_PaymentError_Refunded {
15222 err: *mut wire_cst_list_prim_u_8_strict,
15223 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15224 }
15225 #[repr(C)]
15226 #[derive(Clone, Copy)]
15227 pub struct wire_cst_PaymentError_SendError {
15228 err: *mut wire_cst_list_prim_u_8_strict,
15229 }
15230 #[repr(C)]
15231 #[derive(Clone, Copy)]
15232 pub struct wire_cst_PaymentError_SignerError {
15233 err: *mut wire_cst_list_prim_u_8_strict,
15234 }
15235 #[repr(C)]
15236 #[derive(Clone, Copy)]
15237 pub struct wire_cst_prepare_buy_bitcoin_request {
15238 provider: i32,
15239 amount_sat: u64,
15240 }
15241 #[repr(C)]
15242 #[derive(Clone, Copy)]
15243 pub struct wire_cst_prepare_buy_bitcoin_response {
15244 provider: i32,
15245 amount_sat: u64,
15246 fees_sat: u64,
15247 }
15248 #[repr(C)]
15249 #[derive(Clone, Copy)]
15250 pub struct wire_cst_prepare_ln_url_pay_request {
15251 data: wire_cst_ln_url_pay_request_data,
15252 amount: wire_cst_pay_amount,
15253 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15254 comment: *mut wire_cst_list_prim_u_8_strict,
15255 validate_success_action_url: *mut bool,
15256 }
15257 #[repr(C)]
15258 #[derive(Clone, Copy)]
15259 pub struct wire_cst_prepare_ln_url_pay_response {
15260 destination: wire_cst_send_destination,
15261 fees_sat: u64,
15262 data: wire_cst_ln_url_pay_request_data,
15263 amount: wire_cst_pay_amount,
15264 comment: *mut wire_cst_list_prim_u_8_strict,
15265 success_action: *mut wire_cst_success_action,
15266 }
15267 #[repr(C)]
15268 #[derive(Clone, Copy)]
15269 pub struct wire_cst_prepare_pay_onchain_request {
15270 amount: wire_cst_pay_amount,
15271 fee_rate_sat_per_vbyte: *mut u32,
15272 }
15273 #[repr(C)]
15274 #[derive(Clone, Copy)]
15275 pub struct wire_cst_prepare_pay_onchain_response {
15276 receiver_amount_sat: u64,
15277 claim_fees_sat: u64,
15278 total_fees_sat: u64,
15279 }
15280 #[repr(C)]
15281 #[derive(Clone, Copy)]
15282 pub struct wire_cst_prepare_receive_request {
15283 payment_method: i32,
15284 amount: *mut wire_cst_receive_amount,
15285 }
15286 #[repr(C)]
15287 #[derive(Clone, Copy)]
15288 pub struct wire_cst_prepare_receive_response {
15289 payment_method: i32,
15290 fees_sat: u64,
15291 amount: *mut wire_cst_receive_amount,
15292 min_payer_amount_sat: *mut u64,
15293 max_payer_amount_sat: *mut u64,
15294 swapper_feerate: *mut f64,
15295 }
15296 #[repr(C)]
15297 #[derive(Clone, Copy)]
15298 pub struct wire_cst_prepare_refund_request {
15299 swap_address: *mut wire_cst_list_prim_u_8_strict,
15300 refund_address: *mut wire_cst_list_prim_u_8_strict,
15301 fee_rate_sat_per_vbyte: u32,
15302 }
15303 #[repr(C)]
15304 #[derive(Clone, Copy)]
15305 pub struct wire_cst_prepare_refund_response {
15306 tx_vsize: u32,
15307 tx_fee_sat: u64,
15308 last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15309 }
15310 #[repr(C)]
15311 #[derive(Clone, Copy)]
15312 pub struct wire_cst_prepare_send_request {
15313 destination: *mut wire_cst_list_prim_u_8_strict,
15314 amount: *mut wire_cst_pay_amount,
15315 }
15316 #[repr(C)]
15317 #[derive(Clone, Copy)]
15318 pub struct wire_cst_prepare_send_response {
15319 destination: wire_cst_send_destination,
15320 amount: *mut wire_cst_pay_amount,
15321 fees_sat: *mut u64,
15322 estimated_asset_fees: *mut f64,
15323 }
15324 #[repr(C)]
15325 #[derive(Clone, Copy)]
15326 pub struct wire_cst_rate {
15327 coin: *mut wire_cst_list_prim_u_8_strict,
15328 value: f64,
15329 }
15330 #[repr(C)]
15331 #[derive(Clone, Copy)]
15332 pub struct wire_cst_receive_amount {
15333 tag: i32,
15334 kind: ReceiveAmountKind,
15335 }
15336 #[repr(C)]
15337 #[derive(Clone, Copy)]
15338 pub union ReceiveAmountKind {
15339 Bitcoin: wire_cst_ReceiveAmount_Bitcoin,
15340 Asset: wire_cst_ReceiveAmount_Asset,
15341 nil__: (),
15342 }
15343 #[repr(C)]
15344 #[derive(Clone, Copy)]
15345 pub struct wire_cst_ReceiveAmount_Bitcoin {
15346 payer_amount_sat: u64,
15347 }
15348 #[repr(C)]
15349 #[derive(Clone, Copy)]
15350 pub struct wire_cst_ReceiveAmount_Asset {
15351 asset_id: *mut wire_cst_list_prim_u_8_strict,
15352 payer_amount: *mut f64,
15353 }
15354 #[repr(C)]
15355 #[derive(Clone, Copy)]
15356 pub struct wire_cst_receive_payment_request {
15357 prepare_response: wire_cst_prepare_receive_response,
15358 description: *mut wire_cst_list_prim_u_8_strict,
15359 use_description_hash: *mut bool,
15360 payer_note: *mut wire_cst_list_prim_u_8_strict,
15361 }
15362 #[repr(C)]
15363 #[derive(Clone, Copy)]
15364 pub struct wire_cst_receive_payment_response {
15365 destination: *mut wire_cst_list_prim_u_8_strict,
15366 }
15367 #[repr(C)]
15368 #[derive(Clone, Copy)]
15369 pub struct wire_cst_recommended_fees {
15370 fastest_fee: u64,
15371 half_hour_fee: u64,
15372 hour_fee: u64,
15373 economy_fee: u64,
15374 minimum_fee: u64,
15375 }
15376 #[repr(C)]
15377 #[derive(Clone, Copy)]
15378 pub struct wire_cst_refund_request {
15379 swap_address: *mut wire_cst_list_prim_u_8_strict,
15380 refund_address: *mut wire_cst_list_prim_u_8_strict,
15381 fee_rate_sat_per_vbyte: u32,
15382 }
15383 #[repr(C)]
15384 #[derive(Clone, Copy)]
15385 pub struct wire_cst_refund_response {
15386 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15387 }
15388 #[repr(C)]
15389 #[derive(Clone, Copy)]
15390 pub struct wire_cst_refundable_swap {
15391 swap_address: *mut wire_cst_list_prim_u_8_strict,
15392 timestamp: u32,
15393 amount_sat: u64,
15394 last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15395 }
15396 #[repr(C)]
15397 #[derive(Clone, Copy)]
15398 pub struct wire_cst_restore_request {
15399 backup_path: *mut wire_cst_list_prim_u_8_strict,
15400 }
15401 #[repr(C)]
15402 #[derive(Clone, Copy)]
15403 pub struct wire_cst_route_hint {
15404 hops: *mut wire_cst_list_route_hint_hop,
15405 }
15406 #[repr(C)]
15407 #[derive(Clone, Copy)]
15408 pub struct wire_cst_route_hint_hop {
15409 src_node_id: *mut wire_cst_list_prim_u_8_strict,
15410 short_channel_id: *mut wire_cst_list_prim_u_8_strict,
15411 fees_base_msat: u32,
15412 fees_proportional_millionths: u32,
15413 cltv_expiry_delta: u64,
15414 htlc_minimum_msat: *mut u64,
15415 htlc_maximum_msat: *mut u64,
15416 }
15417 #[repr(C)]
15418 #[derive(Clone, Copy)]
15419 pub struct wire_cst_sdk_error {
15420 tag: i32,
15421 kind: SdkErrorKind,
15422 }
15423 #[repr(C)]
15424 #[derive(Clone, Copy)]
15425 pub union SdkErrorKind {
15426 Generic: wire_cst_SdkError_Generic,
15427 ServiceConnectivity: wire_cst_SdkError_ServiceConnectivity,
15428 nil__: (),
15429 }
15430 #[repr(C)]
15431 #[derive(Clone, Copy)]
15432 pub struct wire_cst_SdkError_Generic {
15433 err: *mut wire_cst_list_prim_u_8_strict,
15434 }
15435 #[repr(C)]
15436 #[derive(Clone, Copy)]
15437 pub struct wire_cst_SdkError_ServiceConnectivity {
15438 err: *mut wire_cst_list_prim_u_8_strict,
15439 }
15440 #[repr(C)]
15441 #[derive(Clone, Copy)]
15442 pub struct wire_cst_sdk_event {
15443 tag: i32,
15444 kind: SdkEventKind,
15445 }
15446 #[repr(C)]
15447 #[derive(Clone, Copy)]
15448 pub union SdkEventKind {
15449 PaymentFailed: wire_cst_SdkEvent_PaymentFailed,
15450 PaymentPending: wire_cst_SdkEvent_PaymentPending,
15451 PaymentRefundable: wire_cst_SdkEvent_PaymentRefundable,
15452 PaymentRefunded: wire_cst_SdkEvent_PaymentRefunded,
15453 PaymentRefundPending: wire_cst_SdkEvent_PaymentRefundPending,
15454 PaymentSucceeded: wire_cst_SdkEvent_PaymentSucceeded,
15455 PaymentWaitingConfirmation: wire_cst_SdkEvent_PaymentWaitingConfirmation,
15456 PaymentWaitingFeeAcceptance: wire_cst_SdkEvent_PaymentWaitingFeeAcceptance,
15457 DataSynced: wire_cst_SdkEvent_DataSynced,
15458 nil__: (),
15459 }
15460 #[repr(C)]
15461 #[derive(Clone, Copy)]
15462 pub struct wire_cst_SdkEvent_PaymentFailed {
15463 details: *mut wire_cst_payment,
15464 }
15465 #[repr(C)]
15466 #[derive(Clone, Copy)]
15467 pub struct wire_cst_SdkEvent_PaymentPending {
15468 details: *mut wire_cst_payment,
15469 }
15470 #[repr(C)]
15471 #[derive(Clone, Copy)]
15472 pub struct wire_cst_SdkEvent_PaymentRefundable {
15473 details: *mut wire_cst_payment,
15474 }
15475 #[repr(C)]
15476 #[derive(Clone, Copy)]
15477 pub struct wire_cst_SdkEvent_PaymentRefunded {
15478 details: *mut wire_cst_payment,
15479 }
15480 #[repr(C)]
15481 #[derive(Clone, Copy)]
15482 pub struct wire_cst_SdkEvent_PaymentRefundPending {
15483 details: *mut wire_cst_payment,
15484 }
15485 #[repr(C)]
15486 #[derive(Clone, Copy)]
15487 pub struct wire_cst_SdkEvent_PaymentSucceeded {
15488 details: *mut wire_cst_payment,
15489 }
15490 #[repr(C)]
15491 #[derive(Clone, Copy)]
15492 pub struct wire_cst_SdkEvent_PaymentWaitingConfirmation {
15493 details: *mut wire_cst_payment,
15494 }
15495 #[repr(C)]
15496 #[derive(Clone, Copy)]
15497 pub struct wire_cst_SdkEvent_PaymentWaitingFeeAcceptance {
15498 details: *mut wire_cst_payment,
15499 }
15500 #[repr(C)]
15501 #[derive(Clone, Copy)]
15502 pub struct wire_cst_SdkEvent_DataSynced {
15503 did_pull_new_records: bool,
15504 }
15505 #[repr(C)]
15506 #[derive(Clone, Copy)]
15507 pub struct wire_cst_send_destination {
15508 tag: i32,
15509 kind: SendDestinationKind,
15510 }
15511 #[repr(C)]
15512 #[derive(Clone, Copy)]
15513 pub union SendDestinationKind {
15514 LiquidAddress: wire_cst_SendDestination_LiquidAddress,
15515 Bolt11: wire_cst_SendDestination_Bolt11,
15516 Bolt12: wire_cst_SendDestination_Bolt12,
15517 nil__: (),
15518 }
15519 #[repr(C)]
15520 #[derive(Clone, Copy)]
15521 pub struct wire_cst_SendDestination_LiquidAddress {
15522 address_data: *mut wire_cst_liquid_address_data,
15523 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15524 }
15525 #[repr(C)]
15526 #[derive(Clone, Copy)]
15527 pub struct wire_cst_SendDestination_Bolt11 {
15528 invoice: *mut wire_cst_ln_invoice,
15529 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15530 }
15531 #[repr(C)]
15532 #[derive(Clone, Copy)]
15533 pub struct wire_cst_SendDestination_Bolt12 {
15534 offer: *mut wire_cst_ln_offer,
15535 receiver_amount_sat: u64,
15536 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15537 }
15538 #[repr(C)]
15539 #[derive(Clone, Copy)]
15540 pub struct wire_cst_send_payment_request {
15541 prepare_response: wire_cst_prepare_send_response,
15542 use_asset_fees: *mut bool,
15543 payer_note: *mut wire_cst_list_prim_u_8_strict,
15544 }
15545 #[repr(C)]
15546 #[derive(Clone, Copy)]
15547 pub struct wire_cst_send_payment_response {
15548 payment: wire_cst_payment,
15549 }
15550 #[repr(C)]
15551 #[derive(Clone, Copy)]
15552 pub struct wire_cst_sign_message_request {
15553 message: *mut wire_cst_list_prim_u_8_strict,
15554 }
15555 #[repr(C)]
15556 #[derive(Clone, Copy)]
15557 pub struct wire_cst_sign_message_response {
15558 signature: *mut wire_cst_list_prim_u_8_strict,
15559 }
15560 #[repr(C)]
15561 #[derive(Clone, Copy)]
15562 pub struct wire_cst_success_action {
15563 tag: i32,
15564 kind: SuccessActionKind,
15565 }
15566 #[repr(C)]
15567 #[derive(Clone, Copy)]
15568 pub union SuccessActionKind {
15569 Aes: wire_cst_SuccessAction_Aes,
15570 Message: wire_cst_SuccessAction_Message,
15571 Url: wire_cst_SuccessAction_Url,
15572 nil__: (),
15573 }
15574 #[repr(C)]
15575 #[derive(Clone, Copy)]
15576 pub struct wire_cst_SuccessAction_Aes {
15577 data: *mut wire_cst_aes_success_action_data,
15578 }
15579 #[repr(C)]
15580 #[derive(Clone, Copy)]
15581 pub struct wire_cst_SuccessAction_Message {
15582 data: *mut wire_cst_message_success_action_data,
15583 }
15584 #[repr(C)]
15585 #[derive(Clone, Copy)]
15586 pub struct wire_cst_SuccessAction_Url {
15587 data: *mut wire_cst_url_success_action_data,
15588 }
15589 #[repr(C)]
15590 #[derive(Clone, Copy)]
15591 pub struct wire_cst_success_action_processed {
15592 tag: i32,
15593 kind: SuccessActionProcessedKind,
15594 }
15595 #[repr(C)]
15596 #[derive(Clone, Copy)]
15597 pub union SuccessActionProcessedKind {
15598 Aes: wire_cst_SuccessActionProcessed_Aes,
15599 Message: wire_cst_SuccessActionProcessed_Message,
15600 Url: wire_cst_SuccessActionProcessed_Url,
15601 nil__: (),
15602 }
15603 #[repr(C)]
15604 #[derive(Clone, Copy)]
15605 pub struct wire_cst_SuccessActionProcessed_Aes {
15606 result: *mut wire_cst_aes_success_action_data_result,
15607 }
15608 #[repr(C)]
15609 #[derive(Clone, Copy)]
15610 pub struct wire_cst_SuccessActionProcessed_Message {
15611 data: *mut wire_cst_message_success_action_data,
15612 }
15613 #[repr(C)]
15614 #[derive(Clone, Copy)]
15615 pub struct wire_cst_SuccessActionProcessed_Url {
15616 data: *mut wire_cst_url_success_action_data,
15617 }
15618 #[repr(C)]
15619 #[derive(Clone, Copy)]
15620 pub struct wire_cst_symbol {
15621 grapheme: *mut wire_cst_list_prim_u_8_strict,
15622 template: *mut wire_cst_list_prim_u_8_strict,
15623 rtl: *mut bool,
15624 position: *mut u32,
15625 }
15626 #[repr(C)]
15627 #[derive(Clone, Copy)]
15628 pub struct wire_cst_url_success_action_data {
15629 description: *mut wire_cst_list_prim_u_8_strict,
15630 url: *mut wire_cst_list_prim_u_8_strict,
15631 matches_callback_domain: bool,
15632 }
15633 #[repr(C)]
15634 #[derive(Clone, Copy)]
15635 pub struct wire_cst_wallet_info {
15636 balance_sat: u64,
15637 pending_send_sat: u64,
15638 pending_receive_sat: u64,
15639 fingerprint: *mut wire_cst_list_prim_u_8_strict,
15640 pubkey: *mut wire_cst_list_prim_u_8_strict,
15641 asset_balances: *mut wire_cst_list_asset_balance,
15642 }
15643}
15644#[cfg(not(target_family = "wasm"))]
15645pub use io::*;