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_cacheDir = <Option<String>>::sse_decode(deserializer);
2632 let mut var_network = <crate::model::LiquidNetwork>::sse_decode(deserializer);
2633 let mut var_paymentTimeoutSec = <u64>::sse_decode(deserializer);
2634 let mut var_syncServiceUrl = <Option<String>>::sse_decode(deserializer);
2635 let mut var_zeroConfMaxAmountSat = <Option<u64>>::sse_decode(deserializer);
2636 let mut var_breezApiKey = <Option<String>>::sse_decode(deserializer);
2637 let mut var_externalInputParsers =
2638 <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_decode(deserializer);
2639 let mut var_useDefaultExternalInputParsers = <bool>::sse_decode(deserializer);
2640 let mut var_onchainFeeRateLeewaySatPerVbyte = <Option<u32>>::sse_decode(deserializer);
2641 let mut var_assetMetadata =
2642 <Option<Vec<crate::model::AssetMetadata>>>::sse_decode(deserializer);
2643 let mut var_sideswapApiKey = <Option<String>>::sse_decode(deserializer);
2644 return crate::model::Config {
2645 liquid_explorer: var_liquidExplorer,
2646 bitcoin_explorer: var_bitcoinExplorer,
2647 working_dir: var_workingDir,
2648 cache_dir: var_cacheDir,
2649 network: var_network,
2650 payment_timeout_sec: var_paymentTimeoutSec,
2651 sync_service_url: var_syncServiceUrl,
2652 zero_conf_max_amount_sat: var_zeroConfMaxAmountSat,
2653 breez_api_key: var_breezApiKey,
2654 external_input_parsers: var_externalInputParsers,
2655 use_default_external_input_parsers: var_useDefaultExternalInputParsers,
2656 onchain_fee_rate_leeway_sat_per_vbyte: var_onchainFeeRateLeewaySatPerVbyte,
2657 asset_metadata: var_assetMetadata,
2658 sideswap_api_key: var_sideswapApiKey,
2659 };
2660 }
2661}
2662
2663impl SseDecode for crate::model::ConnectRequest {
2664 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2666 let mut var_config = <crate::model::Config>::sse_decode(deserializer);
2667 let mut var_mnemonic = <Option<String>>::sse_decode(deserializer);
2668 let mut var_passphrase = <Option<String>>::sse_decode(deserializer);
2669 let mut var_seed = <Option<Vec<u8>>>::sse_decode(deserializer);
2670 return crate::model::ConnectRequest {
2671 config: var_config,
2672 mnemonic: var_mnemonic,
2673 passphrase: var_passphrase,
2674 seed: var_seed,
2675 };
2676 }
2677}
2678
2679impl SseDecode for crate::model::CreateBolt12InvoiceRequest {
2680 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2682 let mut var_offer = <String>::sse_decode(deserializer);
2683 let mut var_invoiceRequest = <String>::sse_decode(deserializer);
2684 return crate::model::CreateBolt12InvoiceRequest {
2685 offer: var_offer,
2686 invoice_request: var_invoiceRequest,
2687 };
2688 }
2689}
2690
2691impl SseDecode for crate::model::CreateBolt12InvoiceResponse {
2692 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2694 let mut var_invoice = <String>::sse_decode(deserializer);
2695 return crate::model::CreateBolt12InvoiceResponse {
2696 invoice: var_invoice,
2697 };
2698 }
2699}
2700
2701impl SseDecode for crate::bindings::CurrencyInfo {
2702 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2704 let mut var_name = <String>::sse_decode(deserializer);
2705 let mut var_fractionSize = <u32>::sse_decode(deserializer);
2706 let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
2707 let mut var_symbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2708 let mut var_uniqSymbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2709 let mut var_localizedName = <Vec<crate::bindings::LocalizedName>>::sse_decode(deserializer);
2710 let mut var_localeOverrides =
2711 <Vec<crate::bindings::LocaleOverrides>>::sse_decode(deserializer);
2712 return crate::bindings::CurrencyInfo {
2713 name: var_name,
2714 fraction_size: var_fractionSize,
2715 spacing: var_spacing,
2716 symbol: var_symbol,
2717 uniq_symbol: var_uniqSymbol,
2718 localized_name: var_localizedName,
2719 locale_overrides: var_localeOverrides,
2720 };
2721 }
2722}
2723
2724impl SseDecode for crate::bindings::ExternalInputParser {
2725 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2727 let mut var_providerId = <String>::sse_decode(deserializer);
2728 let mut var_inputRegex = <String>::sse_decode(deserializer);
2729 let mut var_parserUrl = <String>::sse_decode(deserializer);
2730 return crate::bindings::ExternalInputParser {
2731 provider_id: var_providerId,
2732 input_regex: var_inputRegex,
2733 parser_url: var_parserUrl,
2734 };
2735 }
2736}
2737
2738impl SseDecode for f64 {
2739 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2741 deserializer.cursor.read_f64::<NativeEndian>().unwrap()
2742 }
2743}
2744
2745impl SseDecode for crate::model::FetchPaymentProposedFeesRequest {
2746 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2748 let mut var_swapId = <String>::sse_decode(deserializer);
2749 return crate::model::FetchPaymentProposedFeesRequest {
2750 swap_id: var_swapId,
2751 };
2752 }
2753}
2754
2755impl SseDecode for crate::model::FetchPaymentProposedFeesResponse {
2756 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2758 let mut var_swapId = <String>::sse_decode(deserializer);
2759 let mut var_feesSat = <u64>::sse_decode(deserializer);
2760 let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
2761 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
2762 return crate::model::FetchPaymentProposedFeesResponse {
2763 swap_id: var_swapId,
2764 fees_sat: var_feesSat,
2765 payer_amount_sat: var_payerAmountSat,
2766 receiver_amount_sat: var_receiverAmountSat,
2767 };
2768 }
2769}
2770
2771impl SseDecode for crate::bindings::FiatCurrency {
2772 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2774 let mut var_id = <String>::sse_decode(deserializer);
2775 let mut var_info = <crate::bindings::CurrencyInfo>::sse_decode(deserializer);
2776 return crate::bindings::FiatCurrency {
2777 id: var_id,
2778 info: var_info,
2779 };
2780 }
2781}
2782
2783impl SseDecode for crate::model::GetInfoResponse {
2784 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2786 let mut var_walletInfo = <crate::model::WalletInfo>::sse_decode(deserializer);
2787 let mut var_blockchainInfo = <crate::model::BlockchainInfo>::sse_decode(deserializer);
2788 return crate::model::GetInfoResponse {
2789 wallet_info: var_walletInfo,
2790 blockchain_info: var_blockchainInfo,
2791 };
2792 }
2793}
2794
2795impl SseDecode for crate::model::GetPaymentRequest {
2796 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2798 let mut tag_ = <i32>::sse_decode(deserializer);
2799 match tag_ {
2800 0 => {
2801 let mut var_paymentHash = <String>::sse_decode(deserializer);
2802 return crate::model::GetPaymentRequest::PaymentHash {
2803 payment_hash: var_paymentHash,
2804 };
2805 }
2806 1 => {
2807 let mut var_swapId = <String>::sse_decode(deserializer);
2808 return crate::model::GetPaymentRequest::SwapId {
2809 swap_id: var_swapId,
2810 };
2811 }
2812 _ => {
2813 unimplemented!("");
2814 }
2815 }
2816 }
2817}
2818
2819impl SseDecode for i32 {
2820 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2822 deserializer.cursor.read_i32::<NativeEndian>().unwrap()
2823 }
2824}
2825
2826impl SseDecode for i64 {
2827 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2829 deserializer.cursor.read_i64::<NativeEndian>().unwrap()
2830 }
2831}
2832
2833impl SseDecode for crate::bindings::InputType {
2834 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2836 let mut tag_ = <i32>::sse_decode(deserializer);
2837 match tag_ {
2838 0 => {
2839 let mut var_address =
2840 <crate::bindings::BitcoinAddressData>::sse_decode(deserializer);
2841 return crate::bindings::InputType::BitcoinAddress {
2842 address: var_address,
2843 };
2844 }
2845 1 => {
2846 let mut var_address =
2847 <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
2848 return crate::bindings::InputType::LiquidAddress {
2849 address: var_address,
2850 };
2851 }
2852 2 => {
2853 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
2854 return crate::bindings::InputType::Bolt11 {
2855 invoice: var_invoice,
2856 };
2857 }
2858 3 => {
2859 let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
2860 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2861 return crate::bindings::InputType::Bolt12Offer {
2862 offer: var_offer,
2863 bip353_address: var_bip353Address,
2864 };
2865 }
2866 4 => {
2867 let mut var_nodeId = <String>::sse_decode(deserializer);
2868 return crate::bindings::InputType::NodeId {
2869 node_id: var_nodeId,
2870 };
2871 }
2872 5 => {
2873 let mut var_url = <String>::sse_decode(deserializer);
2874 return crate::bindings::InputType::Url { url: var_url };
2875 }
2876 6 => {
2877 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
2878 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2879 return crate::bindings::InputType::LnUrlPay {
2880 data: var_data,
2881 bip353_address: var_bip353Address,
2882 };
2883 }
2884 7 => {
2885 let mut var_data =
2886 <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
2887 return crate::bindings::InputType::LnUrlWithdraw { data: var_data };
2888 }
2889 8 => {
2890 let mut var_data =
2891 <crate::bindings::LnUrlAuthRequestData>::sse_decode(deserializer);
2892 return crate::bindings::InputType::LnUrlAuth { data: var_data };
2893 }
2894 9 => {
2895 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
2896 return crate::bindings::InputType::LnUrlError { data: var_data };
2897 }
2898 _ => {
2899 unimplemented!("");
2900 }
2901 }
2902 }
2903}
2904
2905impl SseDecode for crate::model::LightningPaymentLimitsResponse {
2906 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2908 let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
2909 let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
2910 return crate::model::LightningPaymentLimitsResponse {
2911 send: var_send,
2912 receive: var_receive,
2913 };
2914 }
2915}
2916
2917impl SseDecode for crate::model::Limits {
2918 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2920 let mut var_minSat = <u64>::sse_decode(deserializer);
2921 let mut var_maxSat = <u64>::sse_decode(deserializer);
2922 let mut var_maxZeroConfSat = <u64>::sse_decode(deserializer);
2923 return crate::model::Limits {
2924 min_sat: var_minSat,
2925 max_sat: var_maxSat,
2926 max_zero_conf_sat: var_maxZeroConfSat,
2927 };
2928 }
2929}
2930
2931impl SseDecode for crate::bindings::LiquidAddressData {
2932 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2934 let mut var_address = <String>::sse_decode(deserializer);
2935 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2936 let mut var_assetId = <Option<String>>::sse_decode(deserializer);
2937 let mut var_amount = <Option<f64>>::sse_decode(deserializer);
2938 let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2939 let mut var_label = <Option<String>>::sse_decode(deserializer);
2940 let mut var_message = <Option<String>>::sse_decode(deserializer);
2941 return crate::bindings::LiquidAddressData {
2942 address: var_address,
2943 network: var_network,
2944 asset_id: var_assetId,
2945 amount: var_amount,
2946 amount_sat: var_amountSat,
2947 label: var_label,
2948 message: var_message,
2949 };
2950 }
2951}
2952
2953impl SseDecode for crate::model::LiquidNetwork {
2954 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2956 let mut inner = <i32>::sse_decode(deserializer);
2957 return match inner {
2958 0 => crate::model::LiquidNetwork::Mainnet,
2959 1 => crate::model::LiquidNetwork::Testnet,
2960 2 => crate::model::LiquidNetwork::Regtest,
2961 _ => unreachable!("Invalid variant for LiquidNetwork: {}", inner),
2962 };
2963 }
2964}
2965
2966impl SseDecode for Vec<String> {
2967 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2969 let mut len_ = <i32>::sse_decode(deserializer);
2970 let mut ans_ = vec![];
2971 for idx_ in 0..len_ {
2972 ans_.push(<String>::sse_decode(deserializer));
2973 }
2974 return ans_;
2975 }
2976}
2977
2978impl SseDecode for Vec<crate::model::AssetBalance> {
2979 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2981 let mut len_ = <i32>::sse_decode(deserializer);
2982 let mut ans_ = vec![];
2983 for idx_ in 0..len_ {
2984 ans_.push(<crate::model::AssetBalance>::sse_decode(deserializer));
2985 }
2986 return ans_;
2987 }
2988}
2989
2990impl SseDecode for Vec<crate::model::AssetMetadata> {
2991 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2993 let mut len_ = <i32>::sse_decode(deserializer);
2994 let mut ans_ = vec![];
2995 for idx_ in 0..len_ {
2996 ans_.push(<crate::model::AssetMetadata>::sse_decode(deserializer));
2997 }
2998 return ans_;
2999 }
3000}
3001
3002impl SseDecode for Vec<crate::bindings::ExternalInputParser> {
3003 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3005 let mut len_ = <i32>::sse_decode(deserializer);
3006 let mut ans_ = vec![];
3007 for idx_ in 0..len_ {
3008 ans_.push(<crate::bindings::ExternalInputParser>::sse_decode(
3009 deserializer,
3010 ));
3011 }
3012 return ans_;
3013 }
3014}
3015
3016impl SseDecode for Vec<crate::bindings::FiatCurrency> {
3017 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3019 let mut len_ = <i32>::sse_decode(deserializer);
3020 let mut ans_ = vec![];
3021 for idx_ in 0..len_ {
3022 ans_.push(<crate::bindings::FiatCurrency>::sse_decode(deserializer));
3023 }
3024 return ans_;
3025 }
3026}
3027
3028impl SseDecode for Vec<crate::bindings::LnOfferBlindedPath> {
3029 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3031 let mut len_ = <i32>::sse_decode(deserializer);
3032 let mut ans_ = vec![];
3033 for idx_ in 0..len_ {
3034 ans_.push(<crate::bindings::LnOfferBlindedPath>::sse_decode(
3035 deserializer,
3036 ));
3037 }
3038 return ans_;
3039 }
3040}
3041
3042impl SseDecode for Vec<crate::bindings::LocaleOverrides> {
3043 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3045 let mut len_ = <i32>::sse_decode(deserializer);
3046 let mut ans_ = vec![];
3047 for idx_ in 0..len_ {
3048 ans_.push(<crate::bindings::LocaleOverrides>::sse_decode(deserializer));
3049 }
3050 return ans_;
3051 }
3052}
3053
3054impl SseDecode for Vec<crate::bindings::LocalizedName> {
3055 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3057 let mut len_ = <i32>::sse_decode(deserializer);
3058 let mut ans_ = vec![];
3059 for idx_ in 0..len_ {
3060 ans_.push(<crate::bindings::LocalizedName>::sse_decode(deserializer));
3061 }
3062 return ans_;
3063 }
3064}
3065
3066impl SseDecode for Vec<crate::model::Payment> {
3067 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3069 let mut len_ = <i32>::sse_decode(deserializer);
3070 let mut ans_ = vec![];
3071 for idx_ in 0..len_ {
3072 ans_.push(<crate::model::Payment>::sse_decode(deserializer));
3073 }
3074 return ans_;
3075 }
3076}
3077
3078impl SseDecode for crate::model::ListPaymentDetails {
3079 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3081 let mut tag_ = <i32>::sse_decode(deserializer);
3082 match tag_ {
3083 0 => {
3084 let mut var_assetId = <Option<String>>::sse_decode(deserializer);
3085 let mut var_destination = <Option<String>>::sse_decode(deserializer);
3086 return crate::model::ListPaymentDetails::Liquid {
3087 asset_id: var_assetId,
3088 destination: var_destination,
3089 };
3090 }
3091 1 => {
3092 let mut var_address = <Option<String>>::sse_decode(deserializer);
3093 return crate::model::ListPaymentDetails::Bitcoin {
3094 address: var_address,
3095 };
3096 }
3097 _ => {
3098 unimplemented!("");
3099 }
3100 }
3101 }
3102}
3103
3104impl SseDecode for Vec<crate::model::PaymentState> {
3105 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3107 let mut len_ = <i32>::sse_decode(deserializer);
3108 let mut ans_ = vec![];
3109 for idx_ in 0..len_ {
3110 ans_.push(<crate::model::PaymentState>::sse_decode(deserializer));
3111 }
3112 return ans_;
3113 }
3114}
3115
3116impl SseDecode for Vec<crate::model::PaymentType> {
3117 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3119 let mut len_ = <i32>::sse_decode(deserializer);
3120 let mut ans_ = vec![];
3121 for idx_ in 0..len_ {
3122 ans_.push(<crate::model::PaymentType>::sse_decode(deserializer));
3123 }
3124 return ans_;
3125 }
3126}
3127
3128impl SseDecode for crate::model::ListPaymentsRequest {
3129 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3131 let mut var_filters = <Option<Vec<crate::model::PaymentType>>>::sse_decode(deserializer);
3132 let mut var_states = <Option<Vec<crate::model::PaymentState>>>::sse_decode(deserializer);
3133 let mut var_fromTimestamp = <Option<i64>>::sse_decode(deserializer);
3134 let mut var_toTimestamp = <Option<i64>>::sse_decode(deserializer);
3135 let mut var_offset = <Option<u32>>::sse_decode(deserializer);
3136 let mut var_limit = <Option<u32>>::sse_decode(deserializer);
3137 let mut var_details = <Option<crate::model::ListPaymentDetails>>::sse_decode(deserializer);
3138 let mut var_sortAscending = <Option<bool>>::sse_decode(deserializer);
3139 return crate::model::ListPaymentsRequest {
3140 filters: var_filters,
3141 states: var_states,
3142 from_timestamp: var_fromTimestamp,
3143 to_timestamp: var_toTimestamp,
3144 offset: var_offset,
3145 limit: var_limit,
3146 details: var_details,
3147 sort_ascending: var_sortAscending,
3148 };
3149 }
3150}
3151
3152impl SseDecode for Vec<u8> {
3153 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3155 let mut len_ = <i32>::sse_decode(deserializer);
3156 let mut ans_ = vec![];
3157 for idx_ in 0..len_ {
3158 ans_.push(<u8>::sse_decode(deserializer));
3159 }
3160 return ans_;
3161 }
3162}
3163
3164impl SseDecode for Vec<crate::bindings::Rate> {
3165 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3167 let mut len_ = <i32>::sse_decode(deserializer);
3168 let mut ans_ = vec![];
3169 for idx_ in 0..len_ {
3170 ans_.push(<crate::bindings::Rate>::sse_decode(deserializer));
3171 }
3172 return ans_;
3173 }
3174}
3175
3176impl SseDecode for Vec<crate::model::RefundableSwap> {
3177 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3179 let mut len_ = <i32>::sse_decode(deserializer);
3180 let mut ans_ = vec![];
3181 for idx_ in 0..len_ {
3182 ans_.push(<crate::model::RefundableSwap>::sse_decode(deserializer));
3183 }
3184 return ans_;
3185 }
3186}
3187
3188impl SseDecode for Vec<crate::bindings::RouteHint> {
3189 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3191 let mut len_ = <i32>::sse_decode(deserializer);
3192 let mut ans_ = vec![];
3193 for idx_ in 0..len_ {
3194 ans_.push(<crate::bindings::RouteHint>::sse_decode(deserializer));
3195 }
3196 return ans_;
3197 }
3198}
3199
3200impl SseDecode for Vec<crate::bindings::RouteHintHop> {
3201 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3203 let mut len_ = <i32>::sse_decode(deserializer);
3204 let mut ans_ = vec![];
3205 for idx_ in 0..len_ {
3206 ans_.push(<crate::bindings::RouteHintHop>::sse_decode(deserializer));
3207 }
3208 return ans_;
3209 }
3210}
3211
3212impl SseDecode for crate::bindings::LNInvoice {
3213 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3215 let mut var_bolt11 = <String>::sse_decode(deserializer);
3216 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
3217 let mut var_payeePubkey = <String>::sse_decode(deserializer);
3218 let mut var_paymentHash = <String>::sse_decode(deserializer);
3219 let mut var_description = <Option<String>>::sse_decode(deserializer);
3220 let mut var_descriptionHash = <Option<String>>::sse_decode(deserializer);
3221 let mut var_amountMsat = <Option<u64>>::sse_decode(deserializer);
3222 let mut var_timestamp = <u64>::sse_decode(deserializer);
3223 let mut var_expiry = <u64>::sse_decode(deserializer);
3224 let mut var_routingHints = <Vec<crate::bindings::RouteHint>>::sse_decode(deserializer);
3225 let mut var_paymentSecret = <Vec<u8>>::sse_decode(deserializer);
3226 let mut var_minFinalCltvExpiryDelta = <u64>::sse_decode(deserializer);
3227 return crate::bindings::LNInvoice {
3228 bolt11: var_bolt11,
3229 network: var_network,
3230 payee_pubkey: var_payeePubkey,
3231 payment_hash: var_paymentHash,
3232 description: var_description,
3233 description_hash: var_descriptionHash,
3234 amount_msat: var_amountMsat,
3235 timestamp: var_timestamp,
3236 expiry: var_expiry,
3237 routing_hints: var_routingHints,
3238 payment_secret: var_paymentSecret,
3239 min_final_cltv_expiry_delta: var_minFinalCltvExpiryDelta,
3240 };
3241 }
3242}
3243
3244impl SseDecode for crate::bindings::LNOffer {
3245 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3247 let mut var_offer = <String>::sse_decode(deserializer);
3248 let mut var_chains = <Vec<String>>::sse_decode(deserializer);
3249 let mut var_minAmount = <Option<crate::bindings::Amount>>::sse_decode(deserializer);
3250 let mut var_description = <Option<String>>::sse_decode(deserializer);
3251 let mut var_absoluteExpiry = <Option<u64>>::sse_decode(deserializer);
3252 let mut var_issuer = <Option<String>>::sse_decode(deserializer);
3253 let mut var_signingPubkey = <Option<String>>::sse_decode(deserializer);
3254 let mut var_paths = <Vec<crate::bindings::LnOfferBlindedPath>>::sse_decode(deserializer);
3255 return crate::bindings::LNOffer {
3256 offer: var_offer,
3257 chains: var_chains,
3258 min_amount: var_minAmount,
3259 description: var_description,
3260 absolute_expiry: var_absoluteExpiry,
3261 issuer: var_issuer,
3262 signing_pubkey: var_signingPubkey,
3263 paths: var_paths,
3264 };
3265 }
3266}
3267
3268impl SseDecode for crate::bindings::LnOfferBlindedPath {
3269 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3271 let mut var_blindedHops = <Vec<String>>::sse_decode(deserializer);
3272 return crate::bindings::LnOfferBlindedPath {
3273 blinded_hops: var_blindedHops,
3274 };
3275 }
3276}
3277
3278impl SseDecode for crate::bindings::duplicates::LnUrlAuthError {
3279 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3281 let mut tag_ = <i32>::sse_decode(deserializer);
3282 match tag_ {
3283 0 => {
3284 let mut var_err = <String>::sse_decode(deserializer);
3285 return crate::bindings::duplicates::LnUrlAuthError::Generic { err: var_err };
3286 }
3287 1 => {
3288 let mut var_err = <String>::sse_decode(deserializer);
3289 return crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err: var_err };
3290 }
3291 2 => {
3292 let mut var_err = <String>::sse_decode(deserializer);
3293 return crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
3294 err: var_err,
3295 };
3296 }
3297 _ => {
3298 unimplemented!("");
3299 }
3300 }
3301 }
3302}
3303
3304impl SseDecode for crate::bindings::LnUrlAuthRequestData {
3305 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3307 let mut var_k1 = <String>::sse_decode(deserializer);
3308 let mut var_action = <Option<String>>::sse_decode(deserializer);
3309 let mut var_domain = <String>::sse_decode(deserializer);
3310 let mut var_url = <String>::sse_decode(deserializer);
3311 return crate::bindings::LnUrlAuthRequestData {
3312 k1: var_k1,
3313 action: var_action,
3314 domain: var_domain,
3315 url: var_url,
3316 };
3317 }
3318}
3319
3320impl SseDecode for crate::bindings::duplicates::LnUrlCallbackStatus {
3321 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3323 let mut tag_ = <i32>::sse_decode(deserializer);
3324 match tag_ {
3325 0 => {
3326 return crate::bindings::duplicates::LnUrlCallbackStatus::Ok;
3327 }
3328 1 => {
3329 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3330 return crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
3331 data: var_data,
3332 };
3333 }
3334 _ => {
3335 unimplemented!("");
3336 }
3337 }
3338 }
3339}
3340
3341impl SseDecode for crate::bindings::LnUrlErrorData {
3342 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3344 let mut var_reason = <String>::sse_decode(deserializer);
3345 return crate::bindings::LnUrlErrorData { reason: var_reason };
3346 }
3347}
3348
3349impl SseDecode for crate::model::LnUrlInfo {
3350 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3352 let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3353 let mut var_lnurlPayComment = <Option<String>>::sse_decode(deserializer);
3354 let mut var_lnurlPayDomain = <Option<String>>::sse_decode(deserializer);
3355 let mut var_lnurlPayMetadata = <Option<String>>::sse_decode(deserializer);
3356 let mut var_lnurlPaySuccessAction =
3357 <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3358 let mut var_lnurlPayUnprocessedSuccessAction =
3359 <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
3360 let mut var_lnurlWithdrawEndpoint = <Option<String>>::sse_decode(deserializer);
3361 return crate::model::LnUrlInfo {
3362 ln_address: var_lnAddress,
3363 lnurl_pay_comment: var_lnurlPayComment,
3364 lnurl_pay_domain: var_lnurlPayDomain,
3365 lnurl_pay_metadata: var_lnurlPayMetadata,
3366 lnurl_pay_success_action: var_lnurlPaySuccessAction,
3367 lnurl_pay_unprocessed_success_action: var_lnurlPayUnprocessedSuccessAction,
3368 lnurl_withdraw_endpoint: var_lnurlWithdrawEndpoint,
3369 };
3370 }
3371}
3372
3373impl SseDecode for crate::bindings::duplicates::LnUrlPayError {
3374 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3376 let mut tag_ = <i32>::sse_decode(deserializer);
3377 match tag_ {
3378 0 => {
3379 return crate::bindings::duplicates::LnUrlPayError::AlreadyPaid;
3380 }
3381 1 => {
3382 let mut var_err = <String>::sse_decode(deserializer);
3383 return crate::bindings::duplicates::LnUrlPayError::Generic { err: var_err };
3384 }
3385 2 => {
3386 let mut var_err = <String>::sse_decode(deserializer);
3387 return crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
3388 err: var_err,
3389 };
3390 }
3391 3 => {
3392 let mut var_err = <String>::sse_decode(deserializer);
3393 return crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err: var_err };
3394 }
3395 4 => {
3396 let mut var_err = <String>::sse_decode(deserializer);
3397 return crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err: var_err };
3398 }
3399 5 => {
3400 let mut var_err = <String>::sse_decode(deserializer);
3401 return crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err: var_err };
3402 }
3403 6 => {
3404 let mut var_err = <String>::sse_decode(deserializer);
3405 return crate::bindings::duplicates::LnUrlPayError::InvalidUri { err: var_err };
3406 }
3407 7 => {
3408 let mut var_err = <String>::sse_decode(deserializer);
3409 return crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err: var_err };
3410 }
3411 8 => {
3412 let mut var_err = <String>::sse_decode(deserializer);
3413 return crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err: var_err };
3414 }
3415 9 => {
3416 let mut var_err = <String>::sse_decode(deserializer);
3417 return crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err: var_err };
3418 }
3419 10 => {
3420 let mut var_err = <String>::sse_decode(deserializer);
3421 return crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err: var_err };
3422 }
3423 11 => {
3424 let mut var_err = <String>::sse_decode(deserializer);
3425 return crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
3426 err: var_err,
3427 };
3428 }
3429 12 => {
3430 let mut var_err = <String>::sse_decode(deserializer);
3431 return crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
3432 err: var_err,
3433 };
3434 }
3435 _ => {
3436 unimplemented!("");
3437 }
3438 }
3439 }
3440}
3441
3442impl SseDecode for crate::bindings::LnUrlPayErrorData {
3443 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3445 let mut var_paymentHash = <String>::sse_decode(deserializer);
3446 let mut var_reason = <String>::sse_decode(deserializer);
3447 return crate::bindings::LnUrlPayErrorData {
3448 payment_hash: var_paymentHash,
3449 reason: var_reason,
3450 };
3451 }
3452}
3453
3454impl SseDecode for crate::model::LnUrlPayRequest {
3455 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3457 let mut var_prepareResponse =
3458 <crate::model::PrepareLnUrlPayResponse>::sse_decode(deserializer);
3459 return crate::model::LnUrlPayRequest {
3460 prepare_response: var_prepareResponse,
3461 };
3462 }
3463}
3464
3465impl SseDecode for crate::bindings::LnUrlPayRequestData {
3466 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3468 let mut var_callback = <String>::sse_decode(deserializer);
3469 let mut var_minSendable = <u64>::sse_decode(deserializer);
3470 let mut var_maxSendable = <u64>::sse_decode(deserializer);
3471 let mut var_metadataStr = <String>::sse_decode(deserializer);
3472 let mut var_commentAllowed = <u16>::sse_decode(deserializer);
3473 let mut var_domain = <String>::sse_decode(deserializer);
3474 let mut var_allowsNostr = <bool>::sse_decode(deserializer);
3475 let mut var_nostrPubkey = <Option<String>>::sse_decode(deserializer);
3476 let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3477 return crate::bindings::LnUrlPayRequestData {
3478 callback: var_callback,
3479 min_sendable: var_minSendable,
3480 max_sendable: var_maxSendable,
3481 metadata_str: var_metadataStr,
3482 comment_allowed: var_commentAllowed,
3483 domain: var_domain,
3484 allows_nostr: var_allowsNostr,
3485 nostr_pubkey: var_nostrPubkey,
3486 ln_address: var_lnAddress,
3487 };
3488 }
3489}
3490
3491impl SseDecode for crate::model::LnUrlPayResult {
3492 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3494 let mut tag_ = <i32>::sse_decode(deserializer);
3495 match tag_ {
3496 0 => {
3497 let mut var_data = <crate::model::LnUrlPaySuccessData>::sse_decode(deserializer);
3498 return crate::model::LnUrlPayResult::EndpointSuccess { data: var_data };
3499 }
3500 1 => {
3501 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3502 return crate::model::LnUrlPayResult::EndpointError { data: var_data };
3503 }
3504 2 => {
3505 let mut var_data = <crate::bindings::LnUrlPayErrorData>::sse_decode(deserializer);
3506 return crate::model::LnUrlPayResult::PayError { data: var_data };
3507 }
3508 _ => {
3509 unimplemented!("");
3510 }
3511 }
3512 }
3513}
3514
3515impl SseDecode for crate::model::LnUrlPaySuccessData {
3516 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3518 let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
3519 let mut var_successAction =
3520 <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3521 return crate::model::LnUrlPaySuccessData {
3522 payment: var_payment,
3523 success_action: var_successAction,
3524 };
3525 }
3526}
3527
3528impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawError {
3529 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3531 let mut tag_ = <i32>::sse_decode(deserializer);
3532 match tag_ {
3533 0 => {
3534 let mut var_err = <String>::sse_decode(deserializer);
3535 return crate::bindings::duplicates::LnUrlWithdrawError::Generic { err: var_err };
3536 }
3537 1 => {
3538 let mut var_err = <String>::sse_decode(deserializer);
3539 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
3540 err: var_err,
3541 };
3542 }
3543 2 => {
3544 let mut var_err = <String>::sse_decode(deserializer);
3545 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
3546 err: var_err,
3547 };
3548 }
3549 3 => {
3550 let mut var_err = <String>::sse_decode(deserializer);
3551 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
3552 err: var_err,
3553 };
3554 }
3555 4 => {
3556 let mut var_err = <String>::sse_decode(deserializer);
3557 return crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
3558 err: var_err,
3559 };
3560 }
3561 5 => {
3562 let mut var_err = <String>::sse_decode(deserializer);
3563 return crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
3564 err: var_err,
3565 };
3566 }
3567 _ => {
3568 unimplemented!("");
3569 }
3570 }
3571 }
3572}
3573
3574impl SseDecode for crate::bindings::LnUrlWithdrawRequest {
3575 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3577 let mut var_data = <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
3578 let mut var_amountMsat = <u64>::sse_decode(deserializer);
3579 let mut var_description = <Option<String>>::sse_decode(deserializer);
3580 return crate::bindings::LnUrlWithdrawRequest {
3581 data: var_data,
3582 amount_msat: var_amountMsat,
3583 description: var_description,
3584 };
3585 }
3586}
3587
3588impl SseDecode for crate::bindings::LnUrlWithdrawRequestData {
3589 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3591 let mut var_callback = <String>::sse_decode(deserializer);
3592 let mut var_k1 = <String>::sse_decode(deserializer);
3593 let mut var_defaultDescription = <String>::sse_decode(deserializer);
3594 let mut var_minWithdrawable = <u64>::sse_decode(deserializer);
3595 let mut var_maxWithdrawable = <u64>::sse_decode(deserializer);
3596 return crate::bindings::LnUrlWithdrawRequestData {
3597 callback: var_callback,
3598 k1: var_k1,
3599 default_description: var_defaultDescription,
3600 min_withdrawable: var_minWithdrawable,
3601 max_withdrawable: var_maxWithdrawable,
3602 };
3603 }
3604}
3605
3606impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawResult {
3607 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3609 let mut tag_ = <i32>::sse_decode(deserializer);
3610 match tag_ {
3611 0 => {
3612 let mut var_data =
3613 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3614 deserializer,
3615 );
3616 return crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data: var_data };
3617 }
3618 1 => {
3619 let mut var_data =
3620 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3621 deserializer,
3622 );
3623 return crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
3624 data: var_data,
3625 };
3626 }
3627 2 => {
3628 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3629 return crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
3630 data: var_data,
3631 };
3632 }
3633 _ => {
3634 unimplemented!("");
3635 }
3636 }
3637 }
3638}
3639
3640impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3641 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3643 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
3644 return crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3645 invoice: var_invoice,
3646 };
3647 }
3648}
3649
3650impl SseDecode for crate::bindings::LocaleOverrides {
3651 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3653 let mut var_locale = <String>::sse_decode(deserializer);
3654 let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
3655 let mut var_symbol = <crate::bindings::Symbol>::sse_decode(deserializer);
3656 return crate::bindings::LocaleOverrides {
3657 locale: var_locale,
3658 spacing: var_spacing,
3659 symbol: var_symbol,
3660 };
3661 }
3662}
3663
3664impl SseDecode for crate::bindings::LocalizedName {
3665 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3667 let mut var_locale = <String>::sse_decode(deserializer);
3668 let mut var_name = <String>::sse_decode(deserializer);
3669 return crate::bindings::LocalizedName {
3670 locale: var_locale,
3671 name: var_name,
3672 };
3673 }
3674}
3675
3676impl SseDecode for crate::model::LogEntry {
3677 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3679 let mut var_line = <String>::sse_decode(deserializer);
3680 let mut var_level = <String>::sse_decode(deserializer);
3681 return crate::model::LogEntry {
3682 line: var_line,
3683 level: var_level,
3684 };
3685 }
3686}
3687
3688impl SseDecode for crate::bindings::MessageSuccessActionData {
3689 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3691 let mut var_message = <String>::sse_decode(deserializer);
3692 return crate::bindings::MessageSuccessActionData {
3693 message: var_message,
3694 };
3695 }
3696}
3697
3698impl SseDecode for crate::bindings::Network {
3699 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3701 let mut inner = <i32>::sse_decode(deserializer);
3702 return match inner {
3703 0 => crate::bindings::Network::Bitcoin,
3704 1 => crate::bindings::Network::Testnet,
3705 2 => crate::bindings::Network::Signet,
3706 3 => crate::bindings::Network::Regtest,
3707 _ => unreachable!("Invalid variant for Network: {}", inner),
3708 };
3709 }
3710}
3711
3712impl SseDecode for crate::model::OnchainPaymentLimitsResponse {
3713 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3715 let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
3716 let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
3717 return crate::model::OnchainPaymentLimitsResponse {
3718 send: var_send,
3719 receive: var_receive,
3720 };
3721 }
3722}
3723
3724impl SseDecode for Option<String> {
3725 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3727 if (<bool>::sse_decode(deserializer)) {
3728 return Some(<String>::sse_decode(deserializer));
3729 } else {
3730 return None;
3731 }
3732 }
3733}
3734
3735impl SseDecode for Option<crate::bindings::Amount> {
3736 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3738 if (<bool>::sse_decode(deserializer)) {
3739 return Some(<crate::bindings::Amount>::sse_decode(deserializer));
3740 } else {
3741 return None;
3742 }
3743 }
3744}
3745
3746impl SseDecode for Option<crate::model::AssetInfo> {
3747 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3749 if (<bool>::sse_decode(deserializer)) {
3750 return Some(<crate::model::AssetInfo>::sse_decode(deserializer));
3751 } else {
3752 return None;
3753 }
3754 }
3755}
3756
3757impl SseDecode for Option<bool> {
3758 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3760 if (<bool>::sse_decode(deserializer)) {
3761 return Some(<bool>::sse_decode(deserializer));
3762 } else {
3763 return None;
3764 }
3765 }
3766}
3767
3768impl SseDecode for Option<f64> {
3769 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3771 if (<bool>::sse_decode(deserializer)) {
3772 return Some(<f64>::sse_decode(deserializer));
3773 } else {
3774 return None;
3775 }
3776 }
3777}
3778
3779impl SseDecode for Option<i64> {
3780 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3782 if (<bool>::sse_decode(deserializer)) {
3783 return Some(<i64>::sse_decode(deserializer));
3784 } else {
3785 return None;
3786 }
3787 }
3788}
3789
3790impl SseDecode for Option<crate::model::ListPaymentDetails> {
3791 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3793 if (<bool>::sse_decode(deserializer)) {
3794 return Some(<crate::model::ListPaymentDetails>::sse_decode(deserializer));
3795 } else {
3796 return None;
3797 }
3798 }
3799}
3800
3801impl SseDecode for Option<crate::model::LnUrlInfo> {
3802 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3804 if (<bool>::sse_decode(deserializer)) {
3805 return Some(<crate::model::LnUrlInfo>::sse_decode(deserializer));
3806 } else {
3807 return None;
3808 }
3809 }
3810}
3811
3812impl SseDecode for Option<crate::model::PayAmount> {
3813 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3815 if (<bool>::sse_decode(deserializer)) {
3816 return Some(<crate::model::PayAmount>::sse_decode(deserializer));
3817 } else {
3818 return None;
3819 }
3820 }
3821}
3822
3823impl SseDecode for Option<crate::model::Payment> {
3824 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3826 if (<bool>::sse_decode(deserializer)) {
3827 return Some(<crate::model::Payment>::sse_decode(deserializer));
3828 } else {
3829 return None;
3830 }
3831 }
3832}
3833
3834impl SseDecode for Option<crate::model::ReceiveAmount> {
3835 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3837 if (<bool>::sse_decode(deserializer)) {
3838 return Some(<crate::model::ReceiveAmount>::sse_decode(deserializer));
3839 } else {
3840 return None;
3841 }
3842 }
3843}
3844
3845impl SseDecode for Option<crate::bindings::SuccessAction> {
3846 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3848 if (<bool>::sse_decode(deserializer)) {
3849 return Some(<crate::bindings::SuccessAction>::sse_decode(deserializer));
3850 } else {
3851 return None;
3852 }
3853 }
3854}
3855
3856impl SseDecode for Option<crate::bindings::SuccessActionProcessed> {
3857 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3859 if (<bool>::sse_decode(deserializer)) {
3860 return Some(<crate::bindings::SuccessActionProcessed>::sse_decode(
3861 deserializer,
3862 ));
3863 } else {
3864 return None;
3865 }
3866 }
3867}
3868
3869impl SseDecode for Option<crate::bindings::Symbol> {
3870 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3872 if (<bool>::sse_decode(deserializer)) {
3873 return Some(<crate::bindings::Symbol>::sse_decode(deserializer));
3874 } else {
3875 return None;
3876 }
3877 }
3878}
3879
3880impl SseDecode for Option<u32> {
3881 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3883 if (<bool>::sse_decode(deserializer)) {
3884 return Some(<u32>::sse_decode(deserializer));
3885 } else {
3886 return None;
3887 }
3888 }
3889}
3890
3891impl SseDecode for Option<u64> {
3892 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3894 if (<bool>::sse_decode(deserializer)) {
3895 return Some(<u64>::sse_decode(deserializer));
3896 } else {
3897 return None;
3898 }
3899 }
3900}
3901
3902impl SseDecode for Option<Vec<crate::model::AssetMetadata>> {
3903 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3905 if (<bool>::sse_decode(deserializer)) {
3906 return Some(<Vec<crate::model::AssetMetadata>>::sse_decode(deserializer));
3907 } else {
3908 return None;
3909 }
3910 }
3911}
3912
3913impl SseDecode for Option<Vec<crate::bindings::ExternalInputParser>> {
3914 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3916 if (<bool>::sse_decode(deserializer)) {
3917 return Some(<Vec<crate::bindings::ExternalInputParser>>::sse_decode(
3918 deserializer,
3919 ));
3920 } else {
3921 return None;
3922 }
3923 }
3924}
3925
3926impl SseDecode for Option<Vec<crate::model::PaymentState>> {
3927 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3929 if (<bool>::sse_decode(deserializer)) {
3930 return Some(<Vec<crate::model::PaymentState>>::sse_decode(deserializer));
3931 } else {
3932 return None;
3933 }
3934 }
3935}
3936
3937impl SseDecode for Option<Vec<crate::model::PaymentType>> {
3938 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3940 if (<bool>::sse_decode(deserializer)) {
3941 return Some(<Vec<crate::model::PaymentType>>::sse_decode(deserializer));
3942 } else {
3943 return None;
3944 }
3945 }
3946}
3947
3948impl SseDecode for Option<Vec<u8>> {
3949 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3951 if (<bool>::sse_decode(deserializer)) {
3952 return Some(<Vec<u8>>::sse_decode(deserializer));
3953 } else {
3954 return None;
3955 }
3956 }
3957}
3958
3959impl SseDecode for crate::model::PayAmount {
3960 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3962 let mut tag_ = <i32>::sse_decode(deserializer);
3963 match tag_ {
3964 0 => {
3965 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
3966 return crate::model::PayAmount::Bitcoin {
3967 receiver_amount_sat: var_receiverAmountSat,
3968 };
3969 }
3970 1 => {
3971 let mut var_assetId = <String>::sse_decode(deserializer);
3972 let mut var_receiverAmount = <f64>::sse_decode(deserializer);
3973 let mut var_estimateAssetFees = <Option<bool>>::sse_decode(deserializer);
3974 return crate::model::PayAmount::Asset {
3975 asset_id: var_assetId,
3976 receiver_amount: var_receiverAmount,
3977 estimate_asset_fees: var_estimateAssetFees,
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_claimTxId = <Option<String>>::sse_decode(deserializer);
4048 let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4049 let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4050 return crate::model::PaymentDetails::Lightning {
4051 swap_id: var_swapId,
4052 description: var_description,
4053 liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4054 preimage: var_preimage,
4055 invoice: var_invoice,
4056 bolt12_offer: var_bolt12Offer,
4057 payment_hash: var_paymentHash,
4058 destination_pubkey: var_destinationPubkey,
4059 lnurl_info: var_lnurlInfo,
4060 bip353_address: var_bip353Address,
4061 claim_tx_id: var_claimTxId,
4062 refund_tx_id: var_refundTxId,
4063 refund_tx_amount_sat: var_refundTxAmountSat,
4064 };
4065 }
4066 1 => {
4067 let mut var_destination = <String>::sse_decode(deserializer);
4068 let mut var_description = <String>::sse_decode(deserializer);
4069 let mut var_assetId = <String>::sse_decode(deserializer);
4070 let mut var_assetInfo = <Option<crate::model::AssetInfo>>::sse_decode(deserializer);
4071 let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4072 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4073 return crate::model::PaymentDetails::Liquid {
4074 destination: var_destination,
4075 description: var_description,
4076 asset_id: var_assetId,
4077 asset_info: var_assetInfo,
4078 lnurl_info: var_lnurlInfo,
4079 bip353_address: var_bip353Address,
4080 };
4081 }
4082 2 => {
4083 let mut var_swapId = <String>::sse_decode(deserializer);
4084 let mut var_description = <String>::sse_decode(deserializer);
4085 let mut var_autoAcceptedFees = <bool>::sse_decode(deserializer);
4086 let mut var_liquidExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4087 let mut var_bitcoinExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4088 let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4089 let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4090 let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4091 return crate::model::PaymentDetails::Bitcoin {
4092 swap_id: var_swapId,
4093 description: var_description,
4094 auto_accepted_fees: var_autoAcceptedFees,
4095 liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4096 bitcoin_expiration_blockheight: var_bitcoinExpirationBlockheight,
4097 claim_tx_id: var_claimTxId,
4098 refund_tx_id: var_refundTxId,
4099 refund_tx_amount_sat: var_refundTxAmountSat,
4100 };
4101 }
4102 _ => {
4103 unimplemented!("");
4104 }
4105 }
4106 }
4107}
4108
4109impl SseDecode for crate::error::PaymentError {
4110 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4112 let mut tag_ = <i32>::sse_decode(deserializer);
4113 match tag_ {
4114 0 => {
4115 return crate::error::PaymentError::AlreadyClaimed;
4116 }
4117 1 => {
4118 return crate::error::PaymentError::AlreadyPaid;
4119 }
4120 2 => {
4121 return crate::error::PaymentError::PaymentInProgress;
4122 }
4123 3 => {
4124 let mut var_min = <u64>::sse_decode(deserializer);
4125 let mut var_max = <u64>::sse_decode(deserializer);
4126 return crate::error::PaymentError::AmountOutOfRange {
4127 min: var_min,
4128 max: var_max,
4129 };
4130 }
4131 4 => {
4132 let mut var_err = <String>::sse_decode(deserializer);
4133 return crate::error::PaymentError::AmountMissing { err: var_err };
4134 }
4135 5 => {
4136 let mut var_err = <String>::sse_decode(deserializer);
4137 return crate::error::PaymentError::AssetError { err: var_err };
4138 }
4139 6 => {
4140 let mut var_err = <String>::sse_decode(deserializer);
4141 return crate::error::PaymentError::InvalidNetwork { err: var_err };
4142 }
4143 7 => {
4144 let mut var_err = <String>::sse_decode(deserializer);
4145 return crate::error::PaymentError::Generic { err: var_err };
4146 }
4147 8 => {
4148 return crate::error::PaymentError::InvalidOrExpiredFees;
4149 }
4150 9 => {
4151 return crate::error::PaymentError::InsufficientFunds;
4152 }
4153 10 => {
4154 let mut var_err = <String>::sse_decode(deserializer);
4155 return crate::error::PaymentError::InvalidDescription { err: var_err };
4156 }
4157 11 => {
4158 let mut var_err = <String>::sse_decode(deserializer);
4159 return crate::error::PaymentError::InvalidInvoice { err: var_err };
4160 }
4161 12 => {
4162 return crate::error::PaymentError::InvalidPreimage;
4163 }
4164 13 => {
4165 return crate::error::PaymentError::PairsNotFound;
4166 }
4167 14 => {
4168 return crate::error::PaymentError::PaymentTimeout;
4169 }
4170 15 => {
4171 return crate::error::PaymentError::PersistError;
4172 }
4173 16 => {
4174 let mut var_err = <String>::sse_decode(deserializer);
4175 return crate::error::PaymentError::ReceiveError { err: var_err };
4176 }
4177 17 => {
4178 let mut var_err = <String>::sse_decode(deserializer);
4179 let mut var_refundTxId = <String>::sse_decode(deserializer);
4180 return crate::error::PaymentError::Refunded {
4181 err: var_err,
4182 refund_tx_id: var_refundTxId,
4183 };
4184 }
4185 18 => {
4186 return crate::error::PaymentError::SelfTransferNotSupported;
4187 }
4188 19 => {
4189 let mut var_err = <String>::sse_decode(deserializer);
4190 return crate::error::PaymentError::SendError { err: var_err };
4191 }
4192 20 => {
4193 let mut var_err = <String>::sse_decode(deserializer);
4194 return crate::error::PaymentError::SignerError { err: var_err };
4195 }
4196 _ => {
4197 unimplemented!("");
4198 }
4199 }
4200 }
4201}
4202
4203impl SseDecode for crate::model::PaymentMethod {
4204 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4206 let mut inner = <i32>::sse_decode(deserializer);
4207 return match inner {
4208 0 => crate::model::PaymentMethod::Lightning,
4209 1 => crate::model::PaymentMethod::Bolt11Invoice,
4210 2 => crate::model::PaymentMethod::Bolt12Offer,
4211 3 => crate::model::PaymentMethod::BitcoinAddress,
4212 4 => crate::model::PaymentMethod::LiquidAddress,
4213 _ => unreachable!("Invalid variant for PaymentMethod: {}", inner),
4214 };
4215 }
4216}
4217
4218impl SseDecode for crate::model::PaymentState {
4219 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4221 let mut inner = <i32>::sse_decode(deserializer);
4222 return match inner {
4223 0 => crate::model::PaymentState::Created,
4224 1 => crate::model::PaymentState::Pending,
4225 2 => crate::model::PaymentState::Complete,
4226 3 => crate::model::PaymentState::Failed,
4227 4 => crate::model::PaymentState::TimedOut,
4228 5 => crate::model::PaymentState::Refundable,
4229 6 => crate::model::PaymentState::RefundPending,
4230 7 => crate::model::PaymentState::WaitingFeeAcceptance,
4231 _ => unreachable!("Invalid variant for PaymentState: {}", inner),
4232 };
4233 }
4234}
4235
4236impl SseDecode for crate::model::PaymentType {
4237 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4239 let mut inner = <i32>::sse_decode(deserializer);
4240 return match inner {
4241 0 => crate::model::PaymentType::Receive,
4242 1 => crate::model::PaymentType::Send,
4243 _ => unreachable!("Invalid variant for PaymentType: {}", inner),
4244 };
4245 }
4246}
4247
4248impl SseDecode for crate::model::PrepareBuyBitcoinRequest {
4249 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4251 let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4252 let mut var_amountSat = <u64>::sse_decode(deserializer);
4253 return crate::model::PrepareBuyBitcoinRequest {
4254 provider: var_provider,
4255 amount_sat: var_amountSat,
4256 };
4257 }
4258}
4259
4260impl SseDecode for crate::model::PrepareBuyBitcoinResponse {
4261 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4263 let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4264 let mut var_amountSat = <u64>::sse_decode(deserializer);
4265 let mut var_feesSat = <u64>::sse_decode(deserializer);
4266 return crate::model::PrepareBuyBitcoinResponse {
4267 provider: var_provider,
4268 amount_sat: var_amountSat,
4269 fees_sat: var_feesSat,
4270 };
4271 }
4272}
4273
4274impl SseDecode for crate::model::PrepareLnUrlPayRequest {
4275 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4277 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4278 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4279 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4280 let mut var_comment = <Option<String>>::sse_decode(deserializer);
4281 let mut var_validateSuccessActionUrl = <Option<bool>>::sse_decode(deserializer);
4282 return crate::model::PrepareLnUrlPayRequest {
4283 data: var_data,
4284 amount: var_amount,
4285 bip353_address: var_bip353Address,
4286 comment: var_comment,
4287 validate_success_action_url: var_validateSuccessActionUrl,
4288 };
4289 }
4290}
4291
4292impl SseDecode for crate::model::PrepareLnUrlPayResponse {
4293 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4295 let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4296 let mut var_feesSat = <u64>::sse_decode(deserializer);
4297 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4298 let mut var_comment = <Option<String>>::sse_decode(deserializer);
4299 let mut var_successAction =
4300 <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
4301 return crate::model::PrepareLnUrlPayResponse {
4302 destination: var_destination,
4303 fees_sat: var_feesSat,
4304 data: var_data,
4305 comment: var_comment,
4306 success_action: var_successAction,
4307 };
4308 }
4309}
4310
4311impl SseDecode for crate::model::PreparePayOnchainRequest {
4312 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4314 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4315 let mut var_feeRateSatPerVbyte = <Option<u32>>::sse_decode(deserializer);
4316 return crate::model::PreparePayOnchainRequest {
4317 amount: var_amount,
4318 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4319 };
4320 }
4321}
4322
4323impl SseDecode for crate::model::PreparePayOnchainResponse {
4324 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4326 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4327 let mut var_claimFeesSat = <u64>::sse_decode(deserializer);
4328 let mut var_totalFeesSat = <u64>::sse_decode(deserializer);
4329 return crate::model::PreparePayOnchainResponse {
4330 receiver_amount_sat: var_receiverAmountSat,
4331 claim_fees_sat: var_claimFeesSat,
4332 total_fees_sat: var_totalFeesSat,
4333 };
4334 }
4335}
4336
4337impl SseDecode for crate::model::PrepareReceiveRequest {
4338 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4340 let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4341 let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4342 return crate::model::PrepareReceiveRequest {
4343 payment_method: var_paymentMethod,
4344 amount: var_amount,
4345 };
4346 }
4347}
4348
4349impl SseDecode for crate::model::PrepareReceiveResponse {
4350 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4352 let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4353 let mut var_feesSat = <u64>::sse_decode(deserializer);
4354 let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4355 let mut var_minPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4356 let mut var_maxPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4357 let mut var_swapperFeerate = <Option<f64>>::sse_decode(deserializer);
4358 return crate::model::PrepareReceiveResponse {
4359 payment_method: var_paymentMethod,
4360 fees_sat: var_feesSat,
4361 amount: var_amount,
4362 min_payer_amount_sat: var_minPayerAmountSat,
4363 max_payer_amount_sat: var_maxPayerAmountSat,
4364 swapper_feerate: var_swapperFeerate,
4365 };
4366 }
4367}
4368
4369impl SseDecode for crate::model::PrepareRefundRequest {
4370 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4372 let mut var_swapAddress = <String>::sse_decode(deserializer);
4373 let mut var_refundAddress = <String>::sse_decode(deserializer);
4374 let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4375 return crate::model::PrepareRefundRequest {
4376 swap_address: var_swapAddress,
4377 refund_address: var_refundAddress,
4378 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4379 };
4380 }
4381}
4382
4383impl SseDecode for crate::model::PrepareRefundResponse {
4384 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4386 let mut var_txVsize = <u32>::sse_decode(deserializer);
4387 let mut var_txFeeSat = <u64>::sse_decode(deserializer);
4388 let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4389 return crate::model::PrepareRefundResponse {
4390 tx_vsize: var_txVsize,
4391 tx_fee_sat: var_txFeeSat,
4392 last_refund_tx_id: var_lastRefundTxId,
4393 };
4394 }
4395}
4396
4397impl SseDecode for crate::model::PrepareSendRequest {
4398 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4400 let mut var_destination = <String>::sse_decode(deserializer);
4401 let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4402 return crate::model::PrepareSendRequest {
4403 destination: var_destination,
4404 amount: var_amount,
4405 };
4406 }
4407}
4408
4409impl SseDecode for crate::model::PrepareSendResponse {
4410 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4412 let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4413 let mut var_feesSat = <Option<u64>>::sse_decode(deserializer);
4414 let mut var_estimatedAssetFees = <Option<f64>>::sse_decode(deserializer);
4415 return crate::model::PrepareSendResponse {
4416 destination: var_destination,
4417 fees_sat: var_feesSat,
4418 estimated_asset_fees: var_estimatedAssetFees,
4419 };
4420 }
4421}
4422
4423impl SseDecode for crate::bindings::Rate {
4424 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4426 let mut var_coin = <String>::sse_decode(deserializer);
4427 let mut var_value = <f64>::sse_decode(deserializer);
4428 return crate::bindings::Rate {
4429 coin: var_coin,
4430 value: var_value,
4431 };
4432 }
4433}
4434
4435impl SseDecode for crate::model::ReceiveAmount {
4436 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4438 let mut tag_ = <i32>::sse_decode(deserializer);
4439 match tag_ {
4440 0 => {
4441 let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
4442 return crate::model::ReceiveAmount::Bitcoin {
4443 payer_amount_sat: var_payerAmountSat,
4444 };
4445 }
4446 1 => {
4447 let mut var_assetId = <String>::sse_decode(deserializer);
4448 let mut var_payerAmount = <Option<f64>>::sse_decode(deserializer);
4449 return crate::model::ReceiveAmount::Asset {
4450 asset_id: var_assetId,
4451 payer_amount: var_payerAmount,
4452 };
4453 }
4454 _ => {
4455 unimplemented!("");
4456 }
4457 }
4458 }
4459}
4460
4461impl SseDecode for crate::model::ReceivePaymentRequest {
4462 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4464 let mut var_prepareResponse =
4465 <crate::model::PrepareReceiveResponse>::sse_decode(deserializer);
4466 let mut var_description = <Option<String>>::sse_decode(deserializer);
4467 let mut var_useDescriptionHash = <Option<bool>>::sse_decode(deserializer);
4468 return crate::model::ReceivePaymentRequest {
4469 prepare_response: var_prepareResponse,
4470 description: var_description,
4471 use_description_hash: var_useDescriptionHash,
4472 };
4473 }
4474}
4475
4476impl SseDecode for crate::model::ReceivePaymentResponse {
4477 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4479 let mut var_destination = <String>::sse_decode(deserializer);
4480 return crate::model::ReceivePaymentResponse {
4481 destination: var_destination,
4482 };
4483 }
4484}
4485
4486impl SseDecode for crate::model::RecommendedFees {
4487 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4489 let mut var_fastestFee = <u64>::sse_decode(deserializer);
4490 let mut var_halfHourFee = <u64>::sse_decode(deserializer);
4491 let mut var_hourFee = <u64>::sse_decode(deserializer);
4492 let mut var_economyFee = <u64>::sse_decode(deserializer);
4493 let mut var_minimumFee = <u64>::sse_decode(deserializer);
4494 return crate::model::RecommendedFees {
4495 fastest_fee: var_fastestFee,
4496 half_hour_fee: var_halfHourFee,
4497 hour_fee: var_hourFee,
4498 economy_fee: var_economyFee,
4499 minimum_fee: var_minimumFee,
4500 };
4501 }
4502}
4503
4504impl SseDecode for crate::model::RefundRequest {
4505 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4507 let mut var_swapAddress = <String>::sse_decode(deserializer);
4508 let mut var_refundAddress = <String>::sse_decode(deserializer);
4509 let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4510 return crate::model::RefundRequest {
4511 swap_address: var_swapAddress,
4512 refund_address: var_refundAddress,
4513 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4514 };
4515 }
4516}
4517
4518impl SseDecode for crate::model::RefundResponse {
4519 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4521 let mut var_refundTxId = <String>::sse_decode(deserializer);
4522 return crate::model::RefundResponse {
4523 refund_tx_id: var_refundTxId,
4524 };
4525 }
4526}
4527
4528impl SseDecode for crate::model::RefundableSwap {
4529 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4531 let mut var_swapAddress = <String>::sse_decode(deserializer);
4532 let mut var_timestamp = <u32>::sse_decode(deserializer);
4533 let mut var_amountSat = <u64>::sse_decode(deserializer);
4534 let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4535 return crate::model::RefundableSwap {
4536 swap_address: var_swapAddress,
4537 timestamp: var_timestamp,
4538 amount_sat: var_amountSat,
4539 last_refund_tx_id: var_lastRefundTxId,
4540 };
4541 }
4542}
4543
4544impl SseDecode for crate::model::RestoreRequest {
4545 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4547 let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
4548 return crate::model::RestoreRequest {
4549 backup_path: var_backupPath,
4550 };
4551 }
4552}
4553
4554impl SseDecode for crate::bindings::RouteHint {
4555 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4557 let mut var_hops = <Vec<crate::bindings::RouteHintHop>>::sse_decode(deserializer);
4558 return crate::bindings::RouteHint { hops: var_hops };
4559 }
4560}
4561
4562impl SseDecode for crate::bindings::RouteHintHop {
4563 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4565 let mut var_srcNodeId = <String>::sse_decode(deserializer);
4566 let mut var_shortChannelId = <String>::sse_decode(deserializer);
4567 let mut var_feesBaseMsat = <u32>::sse_decode(deserializer);
4568 let mut var_feesProportionalMillionths = <u32>::sse_decode(deserializer);
4569 let mut var_cltvExpiryDelta = <u64>::sse_decode(deserializer);
4570 let mut var_htlcMinimumMsat = <Option<u64>>::sse_decode(deserializer);
4571 let mut var_htlcMaximumMsat = <Option<u64>>::sse_decode(deserializer);
4572 return crate::bindings::RouteHintHop {
4573 src_node_id: var_srcNodeId,
4574 short_channel_id: var_shortChannelId,
4575 fees_base_msat: var_feesBaseMsat,
4576 fees_proportional_millionths: var_feesProportionalMillionths,
4577 cltv_expiry_delta: var_cltvExpiryDelta,
4578 htlc_minimum_msat: var_htlcMinimumMsat,
4579 htlc_maximum_msat: var_htlcMaximumMsat,
4580 };
4581 }
4582}
4583
4584impl SseDecode for crate::error::SdkError {
4585 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4587 let mut tag_ = <i32>::sse_decode(deserializer);
4588 match tag_ {
4589 0 => {
4590 return crate::error::SdkError::AlreadyStarted;
4591 }
4592 1 => {
4593 let mut var_err = <String>::sse_decode(deserializer);
4594 return crate::error::SdkError::Generic { err: var_err };
4595 }
4596 2 => {
4597 return crate::error::SdkError::NotStarted;
4598 }
4599 3 => {
4600 let mut var_err = <String>::sse_decode(deserializer);
4601 return crate::error::SdkError::ServiceConnectivity { err: var_err };
4602 }
4603 _ => {
4604 unimplemented!("");
4605 }
4606 }
4607 }
4608}
4609
4610impl SseDecode for crate::model::SdkEvent {
4611 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4613 let mut tag_ = <i32>::sse_decode(deserializer);
4614 match tag_ {
4615 0 => {
4616 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4617 return crate::model::SdkEvent::PaymentFailed {
4618 details: var_details,
4619 };
4620 }
4621 1 => {
4622 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4623 return crate::model::SdkEvent::PaymentPending {
4624 details: var_details,
4625 };
4626 }
4627 2 => {
4628 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4629 return crate::model::SdkEvent::PaymentRefundable {
4630 details: var_details,
4631 };
4632 }
4633 3 => {
4634 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4635 return crate::model::SdkEvent::PaymentRefunded {
4636 details: var_details,
4637 };
4638 }
4639 4 => {
4640 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4641 return crate::model::SdkEvent::PaymentRefundPending {
4642 details: var_details,
4643 };
4644 }
4645 5 => {
4646 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4647 return crate::model::SdkEvent::PaymentSucceeded {
4648 details: var_details,
4649 };
4650 }
4651 6 => {
4652 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4653 return crate::model::SdkEvent::PaymentWaitingConfirmation {
4654 details: var_details,
4655 };
4656 }
4657 7 => {
4658 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4659 return crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
4660 details: var_details,
4661 };
4662 }
4663 8 => {
4664 return crate::model::SdkEvent::Synced;
4665 }
4666 9 => {
4667 let mut var_didPullNewRecords = <bool>::sse_decode(deserializer);
4668 return crate::model::SdkEvent::DataSynced {
4669 did_pull_new_records: var_didPullNewRecords,
4670 };
4671 }
4672 _ => {
4673 unimplemented!("");
4674 }
4675 }
4676 }
4677}
4678
4679impl SseDecode for crate::model::SendDestination {
4680 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4682 let mut tag_ = <i32>::sse_decode(deserializer);
4683 match tag_ {
4684 0 => {
4685 let mut var_addressData =
4686 <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
4687 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4688 return crate::model::SendDestination::LiquidAddress {
4689 address_data: var_addressData,
4690 bip353_address: var_bip353Address,
4691 };
4692 }
4693 1 => {
4694 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
4695 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4696 return crate::model::SendDestination::Bolt11 {
4697 invoice: var_invoice,
4698 bip353_address: var_bip353Address,
4699 };
4700 }
4701 2 => {
4702 let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
4703 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4704 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4705 return crate::model::SendDestination::Bolt12 {
4706 offer: var_offer,
4707 receiver_amount_sat: var_receiverAmountSat,
4708 bip353_address: var_bip353Address,
4709 };
4710 }
4711 _ => {
4712 unimplemented!("");
4713 }
4714 }
4715 }
4716}
4717
4718impl SseDecode for crate::model::SendPaymentRequest {
4719 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4721 let mut var_prepareResponse = <crate::model::PrepareSendResponse>::sse_decode(deserializer);
4722 let mut var_useAssetFees = <Option<bool>>::sse_decode(deserializer);
4723 return crate::model::SendPaymentRequest {
4724 prepare_response: var_prepareResponse,
4725 use_asset_fees: var_useAssetFees,
4726 };
4727 }
4728}
4729
4730impl SseDecode for crate::model::SendPaymentResponse {
4731 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4733 let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
4734 return crate::model::SendPaymentResponse {
4735 payment: var_payment,
4736 };
4737 }
4738}
4739
4740impl SseDecode for crate::model::SignMessageRequest {
4741 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4743 let mut var_message = <String>::sse_decode(deserializer);
4744 return crate::model::SignMessageRequest {
4745 message: var_message,
4746 };
4747 }
4748}
4749
4750impl SseDecode for crate::model::SignMessageResponse {
4751 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4753 let mut var_signature = <String>::sse_decode(deserializer);
4754 return crate::model::SignMessageResponse {
4755 signature: var_signature,
4756 };
4757 }
4758}
4759
4760impl SseDecode for crate::bindings::SuccessAction {
4761 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4763 let mut tag_ = <i32>::sse_decode(deserializer);
4764 match tag_ {
4765 0 => {
4766 let mut var_data =
4767 <crate::bindings::AesSuccessActionData>::sse_decode(deserializer);
4768 return crate::bindings::SuccessAction::Aes { data: var_data };
4769 }
4770 1 => {
4771 let mut var_data =
4772 <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4773 return crate::bindings::SuccessAction::Message { data: var_data };
4774 }
4775 2 => {
4776 let mut var_data =
4777 <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4778 return crate::bindings::SuccessAction::Url { data: var_data };
4779 }
4780 _ => {
4781 unimplemented!("");
4782 }
4783 }
4784 }
4785}
4786
4787impl SseDecode for crate::bindings::SuccessActionProcessed {
4788 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4790 let mut tag_ = <i32>::sse_decode(deserializer);
4791 match tag_ {
4792 0 => {
4793 let mut var_result =
4794 <crate::bindings::AesSuccessActionDataResult>::sse_decode(deserializer);
4795 return crate::bindings::SuccessActionProcessed::Aes { result: var_result };
4796 }
4797 1 => {
4798 let mut var_data =
4799 <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4800 return crate::bindings::SuccessActionProcessed::Message { data: var_data };
4801 }
4802 2 => {
4803 let mut var_data =
4804 <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4805 return crate::bindings::SuccessActionProcessed::Url { data: var_data };
4806 }
4807 _ => {
4808 unimplemented!("");
4809 }
4810 }
4811 }
4812}
4813
4814impl SseDecode for crate::bindings::Symbol {
4815 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4817 let mut var_grapheme = <Option<String>>::sse_decode(deserializer);
4818 let mut var_template = <Option<String>>::sse_decode(deserializer);
4819 let mut var_rtl = <Option<bool>>::sse_decode(deserializer);
4820 let mut var_position = <Option<u32>>::sse_decode(deserializer);
4821 return crate::bindings::Symbol {
4822 grapheme: var_grapheme,
4823 template: var_template,
4824 rtl: var_rtl,
4825 position: var_position,
4826 };
4827 }
4828}
4829
4830impl SseDecode for u16 {
4831 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4833 deserializer.cursor.read_u16::<NativeEndian>().unwrap()
4834 }
4835}
4836
4837impl SseDecode for u32 {
4838 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4840 deserializer.cursor.read_u32::<NativeEndian>().unwrap()
4841 }
4842}
4843
4844impl SseDecode for u64 {
4845 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4847 deserializer.cursor.read_u64::<NativeEndian>().unwrap()
4848 }
4849}
4850
4851impl SseDecode for u8 {
4852 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4854 deserializer.cursor.read_u8().unwrap()
4855 }
4856}
4857
4858impl SseDecode for () {
4859 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
4861}
4862
4863impl SseDecode for crate::bindings::UrlSuccessActionData {
4864 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4866 let mut var_description = <String>::sse_decode(deserializer);
4867 let mut var_url = <String>::sse_decode(deserializer);
4868 let mut var_matchesCallbackDomain = <bool>::sse_decode(deserializer);
4869 return crate::bindings::UrlSuccessActionData {
4870 description: var_description,
4871 url: var_url,
4872 matches_callback_domain: var_matchesCallbackDomain,
4873 };
4874 }
4875}
4876
4877impl SseDecode for usize {
4878 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4880 deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
4881 }
4882}
4883
4884impl SseDecode for crate::model::WalletInfo {
4885 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4887 let mut var_balanceSat = <u64>::sse_decode(deserializer);
4888 let mut var_pendingSendSat = <u64>::sse_decode(deserializer);
4889 let mut var_pendingReceiveSat = <u64>::sse_decode(deserializer);
4890 let mut var_fingerprint = <String>::sse_decode(deserializer);
4891 let mut var_pubkey = <String>::sse_decode(deserializer);
4892 let mut var_assetBalances = <Vec<crate::model::AssetBalance>>::sse_decode(deserializer);
4893 return crate::model::WalletInfo {
4894 balance_sat: var_balanceSat,
4895 pending_send_sat: var_pendingSendSat,
4896 pending_receive_sat: var_pendingReceiveSat,
4897 fingerprint: var_fingerprint,
4898 pubkey: var_pubkey,
4899 asset_balances: var_assetBalances,
4900 };
4901 }
4902}
4903
4904fn pde_ffi_dispatcher_primary_impl(
4905 func_id: i32,
4906 port: flutter_rust_bridge::for_generated::MessagePort,
4907 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4908 rust_vec_len: i32,
4909 data_len: i32,
4910) {
4911 match func_id {
4913 _ => unreachable!(),
4914 }
4915}
4916
4917fn pde_ffi_dispatcher_sync_impl(
4918 func_id: i32,
4919 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4920 rust_vec_len: i32,
4921 data_len: i32,
4922) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
4923 match func_id {
4925 _ => unreachable!(),
4926 }
4927}
4928
4929impl flutter_rust_bridge::IntoDart for FrbWrapper<BindingLiquidSdk> {
4933 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4934 flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0)
4935 .into_dart()
4936 }
4937}
4938impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<BindingLiquidSdk> {}
4939
4940impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<BindingLiquidSdk>> for BindingLiquidSdk {
4941 fn into_into_dart(self) -> FrbWrapper<BindingLiquidSdk> {
4942 self.into()
4943 }
4944}
4945
4946impl flutter_rust_bridge::IntoDart for crate::model::AcceptPaymentProposedFeesRequest {
4948 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4949 [self.response.into_into_dart().into_dart()].into_dart()
4950 }
4951}
4952impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4953 for crate::model::AcceptPaymentProposedFeesRequest
4954{
4955}
4956impl flutter_rust_bridge::IntoIntoDart<crate::model::AcceptPaymentProposedFeesRequest>
4957 for crate::model::AcceptPaymentProposedFeesRequest
4958{
4959 fn into_into_dart(self) -> crate::model::AcceptPaymentProposedFeesRequest {
4960 self
4961 }
4962}
4963impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionData> {
4965 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4966 [
4967 self.0.description.into_into_dart().into_dart(),
4968 self.0.ciphertext.into_into_dart().into_dart(),
4969 self.0.iv.into_into_dart().into_dart(),
4970 ]
4971 .into_dart()
4972 }
4973}
4974impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4975 for FrbWrapper<crate::bindings::AesSuccessActionData>
4976{
4977}
4978impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionData>>
4979 for crate::bindings::AesSuccessActionData
4980{
4981 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionData> {
4982 self.into()
4983 }
4984}
4985impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
4987 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4988 [
4989 self.0.description.into_into_dart().into_dart(),
4990 self.0.plaintext.into_into_dart().into_dart(),
4991 ]
4992 .into_dart()
4993 }
4994}
4995impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4996 for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>
4997{
4998}
4999impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>>
5000 for crate::bindings::AesSuccessActionDataDecrypted
5001{
5002 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5003 self.into()
5004 }
5005}
5006impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5008 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5009 match self.0 {
5010 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
5011 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
5012 }
5013 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
5014 [1.into_dart(), reason.into_into_dart().into_dart()].into_dart()
5015 }
5016 _ => {
5017 unimplemented!("");
5018 }
5019 }
5020 }
5021}
5022impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5023 for FrbWrapper<crate::bindings::AesSuccessActionDataResult>
5024{
5025}
5026impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataResult>>
5027 for crate::bindings::AesSuccessActionDataResult
5028{
5029 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5030 self.into()
5031 }
5032}
5033impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Amount> {
5035 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5036 match self.0 {
5037 crate::bindings::Amount::Bitcoin { amount_msat } => {
5038 [0.into_dart(), amount_msat.into_into_dart().into_dart()].into_dart()
5039 }
5040 crate::bindings::Amount::Currency {
5041 iso4217_code,
5042 fractional_amount,
5043 } => [
5044 1.into_dart(),
5045 iso4217_code.into_into_dart().into_dart(),
5046 fractional_amount.into_into_dart().into_dart(),
5047 ]
5048 .into_dart(),
5049 _ => {
5050 unimplemented!("");
5051 }
5052 }
5053 }
5054}
5055impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5056 for FrbWrapper<crate::bindings::Amount>
5057{
5058}
5059impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Amount>>
5060 for crate::bindings::Amount
5061{
5062 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Amount> {
5063 self.into()
5064 }
5065}
5066impl flutter_rust_bridge::IntoDart for crate::model::AssetBalance {
5068 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5069 [
5070 self.asset_id.into_into_dart().into_dart(),
5071 self.balance_sat.into_into_dart().into_dart(),
5072 self.name.into_into_dart().into_dart(),
5073 self.ticker.into_into_dart().into_dart(),
5074 self.balance.into_into_dart().into_dart(),
5075 ]
5076 .into_dart()
5077 }
5078}
5079impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetBalance {}
5080impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetBalance> for crate::model::AssetBalance {
5081 fn into_into_dart(self) -> crate::model::AssetBalance {
5082 self
5083 }
5084}
5085impl flutter_rust_bridge::IntoDart for crate::model::AssetInfo {
5087 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5088 [
5089 self.name.into_into_dart().into_dart(),
5090 self.ticker.into_into_dart().into_dart(),
5091 self.amount.into_into_dart().into_dart(),
5092 self.fees.into_into_dart().into_dart(),
5093 ]
5094 .into_dart()
5095 }
5096}
5097impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetInfo {}
5098impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetInfo> for crate::model::AssetInfo {
5099 fn into_into_dart(self) -> crate::model::AssetInfo {
5100 self
5101 }
5102}
5103impl flutter_rust_bridge::IntoDart for crate::model::AssetMetadata {
5105 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5106 [
5107 self.asset_id.into_into_dart().into_dart(),
5108 self.name.into_into_dart().into_dart(),
5109 self.ticker.into_into_dart().into_dart(),
5110 self.precision.into_into_dart().into_dart(),
5111 self.fiat_id.into_into_dart().into_dart(),
5112 ]
5113 .into_dart()
5114 }
5115}
5116impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetMetadata {}
5117impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetMetadata>
5118 for crate::model::AssetMetadata
5119{
5120 fn into_into_dart(self) -> crate::model::AssetMetadata {
5121 self
5122 }
5123}
5124impl flutter_rust_bridge::IntoDart for crate::model::BackupRequest {
5126 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5127 [self.backup_path.into_into_dart().into_dart()].into_dart()
5128 }
5129}
5130impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BackupRequest {}
5131impl flutter_rust_bridge::IntoIntoDart<crate::model::BackupRequest>
5132 for crate::model::BackupRequest
5133{
5134 fn into_into_dart(self) -> crate::model::BackupRequest {
5135 self
5136 }
5137}
5138impl flutter_rust_bridge::IntoDart for crate::bindings::BindingEventListener {
5140 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5141 [self.stream.into_into_dart().into_dart()].into_dart()
5142 }
5143}
5144impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5145 for crate::bindings::BindingEventListener
5146{
5147}
5148impl flutter_rust_bridge::IntoIntoDart<crate::bindings::BindingEventListener>
5149 for crate::bindings::BindingEventListener
5150{
5151 fn into_into_dart(self) -> crate::bindings::BindingEventListener {
5152 self
5153 }
5154}
5155impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::BitcoinAddressData> {
5157 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5158 [
5159 self.0.address.into_into_dart().into_dart(),
5160 self.0.network.into_into_dart().into_dart(),
5161 self.0.amount_sat.into_into_dart().into_dart(),
5162 self.0.label.into_into_dart().into_dart(),
5163 self.0.message.into_into_dart().into_dart(),
5164 ]
5165 .into_dart()
5166 }
5167}
5168impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5169 for FrbWrapper<crate::bindings::BitcoinAddressData>
5170{
5171}
5172impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::BitcoinAddressData>>
5173 for crate::bindings::BitcoinAddressData
5174{
5175 fn into_into_dart(self) -> FrbWrapper<crate::bindings::BitcoinAddressData> {
5176 self.into()
5177 }
5178}
5179impl flutter_rust_bridge::IntoDart for crate::model::BlockchainExplorer {
5181 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5182 match self {
5183 crate::model::BlockchainExplorer::Electrum { url } => {
5184 [0.into_dart(), url.into_into_dart().into_dart()].into_dart()
5185 }
5186 crate::model::BlockchainExplorer::Esplora {
5187 url,
5188 use_waterfalls,
5189 } => [
5190 1.into_dart(),
5191 url.into_into_dart().into_dart(),
5192 use_waterfalls.into_into_dart().into_dart(),
5193 ]
5194 .into_dart(),
5195 _ => {
5196 unimplemented!("");
5197 }
5198 }
5199 }
5200}
5201impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5202 for crate::model::BlockchainExplorer
5203{
5204}
5205impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainExplorer>
5206 for crate::model::BlockchainExplorer
5207{
5208 fn into_into_dart(self) -> crate::model::BlockchainExplorer {
5209 self
5210 }
5211}
5212impl flutter_rust_bridge::IntoDart for crate::model::BlockchainInfo {
5214 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5215 [
5216 self.liquid_tip.into_into_dart().into_dart(),
5217 self.bitcoin_tip.into_into_dart().into_dart(),
5218 ]
5219 .into_dart()
5220 }
5221}
5222impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BlockchainInfo {}
5223impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainInfo>
5224 for crate::model::BlockchainInfo
5225{
5226 fn into_into_dart(self) -> crate::model::BlockchainInfo {
5227 self
5228 }
5229}
5230impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinProvider {
5232 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5233 match self {
5234 Self::Moonpay => 0.into_dart(),
5235 _ => unreachable!(),
5236 }
5237 }
5238}
5239impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5240 for crate::model::BuyBitcoinProvider
5241{
5242}
5243impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinProvider>
5244 for crate::model::BuyBitcoinProvider
5245{
5246 fn into_into_dart(self) -> crate::model::BuyBitcoinProvider {
5247 self
5248 }
5249}
5250impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinRequest {
5252 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5253 [
5254 self.prepare_response.into_into_dart().into_dart(),
5255 self.redirect_url.into_into_dart().into_dart(),
5256 ]
5257 .into_dart()
5258 }
5259}
5260impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5261 for crate::model::BuyBitcoinRequest
5262{
5263}
5264impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinRequest>
5265 for crate::model::BuyBitcoinRequest
5266{
5267 fn into_into_dart(self) -> crate::model::BuyBitcoinRequest {
5268 self
5269 }
5270}
5271impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageRequest {
5273 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5274 [
5275 self.message.into_into_dart().into_dart(),
5276 self.pubkey.into_into_dart().into_dart(),
5277 self.signature.into_into_dart().into_dart(),
5278 ]
5279 .into_dart()
5280 }
5281}
5282impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5283 for crate::model::CheckMessageRequest
5284{
5285}
5286impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageRequest>
5287 for crate::model::CheckMessageRequest
5288{
5289 fn into_into_dart(self) -> crate::model::CheckMessageRequest {
5290 self
5291 }
5292}
5293impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageResponse {
5295 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5296 [self.is_valid.into_into_dart().into_dart()].into_dart()
5297 }
5298}
5299impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5300 for crate::model::CheckMessageResponse
5301{
5302}
5303impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageResponse>
5304 for crate::model::CheckMessageResponse
5305{
5306 fn into_into_dart(self) -> crate::model::CheckMessageResponse {
5307 self
5308 }
5309}
5310impl flutter_rust_bridge::IntoDart for crate::model::Config {
5312 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5313 [
5314 self.liquid_explorer.into_into_dart().into_dart(),
5315 self.bitcoin_explorer.into_into_dart().into_dart(),
5316 self.working_dir.into_into_dart().into_dart(),
5317 self.cache_dir.into_into_dart().into_dart(),
5318 self.network.into_into_dart().into_dart(),
5319 self.payment_timeout_sec.into_into_dart().into_dart(),
5320 self.sync_service_url.into_into_dart().into_dart(),
5321 self.zero_conf_max_amount_sat.into_into_dart().into_dart(),
5322 self.breez_api_key.into_into_dart().into_dart(),
5323 self.external_input_parsers.into_into_dart().into_dart(),
5324 self.use_default_external_input_parsers
5325 .into_into_dart()
5326 .into_dart(),
5327 self.onchain_fee_rate_leeway_sat_per_vbyte
5328 .into_into_dart()
5329 .into_dart(),
5330 self.asset_metadata.into_into_dart().into_dart(),
5331 self.sideswap_api_key.into_into_dart().into_dart(),
5332 ]
5333 .into_dart()
5334 }
5335}
5336impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Config {}
5337impl flutter_rust_bridge::IntoIntoDart<crate::model::Config> for crate::model::Config {
5338 fn into_into_dart(self) -> crate::model::Config {
5339 self
5340 }
5341}
5342impl flutter_rust_bridge::IntoDart for crate::model::ConnectRequest {
5344 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5345 [
5346 self.config.into_into_dart().into_dart(),
5347 self.mnemonic.into_into_dart().into_dart(),
5348 self.passphrase.into_into_dart().into_dart(),
5349 self.seed.into_into_dart().into_dart(),
5350 ]
5351 .into_dart()
5352 }
5353}
5354impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ConnectRequest {}
5355impl flutter_rust_bridge::IntoIntoDart<crate::model::ConnectRequest>
5356 for crate::model::ConnectRequest
5357{
5358 fn into_into_dart(self) -> crate::model::ConnectRequest {
5359 self
5360 }
5361}
5362impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceRequest {
5364 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5365 [
5366 self.offer.into_into_dart().into_dart(),
5367 self.invoice_request.into_into_dart().into_dart(),
5368 ]
5369 .into_dart()
5370 }
5371}
5372impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5373 for crate::model::CreateBolt12InvoiceRequest
5374{
5375}
5376impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceRequest>
5377 for crate::model::CreateBolt12InvoiceRequest
5378{
5379 fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceRequest {
5380 self
5381 }
5382}
5383impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceResponse {
5385 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5386 [self.invoice.into_into_dart().into_dart()].into_dart()
5387 }
5388}
5389impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5390 for crate::model::CreateBolt12InvoiceResponse
5391{
5392}
5393impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceResponse>
5394 for crate::model::CreateBolt12InvoiceResponse
5395{
5396 fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceResponse {
5397 self
5398 }
5399}
5400impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::CurrencyInfo> {
5402 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5403 [
5404 self.0.name.into_into_dart().into_dart(),
5405 self.0.fraction_size.into_into_dart().into_dart(),
5406 self.0.spacing.into_into_dart().into_dart(),
5407 self.0.symbol.into_into_dart().into_dart(),
5408 self.0.uniq_symbol.into_into_dart().into_dart(),
5409 self.0.localized_name.into_into_dart().into_dart(),
5410 self.0.locale_overrides.into_into_dart().into_dart(),
5411 ]
5412 .into_dart()
5413 }
5414}
5415impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5416 for FrbWrapper<crate::bindings::CurrencyInfo>
5417{
5418}
5419impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::CurrencyInfo>>
5420 for crate::bindings::CurrencyInfo
5421{
5422 fn into_into_dart(self) -> FrbWrapper<crate::bindings::CurrencyInfo> {
5423 self.into()
5424 }
5425}
5426impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::ExternalInputParser> {
5428 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5429 [
5430 self.0.provider_id.into_into_dart().into_dart(),
5431 self.0.input_regex.into_into_dart().into_dart(),
5432 self.0.parser_url.into_into_dart().into_dart(),
5433 ]
5434 .into_dart()
5435 }
5436}
5437impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5438 for FrbWrapper<crate::bindings::ExternalInputParser>
5439{
5440}
5441impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::ExternalInputParser>>
5442 for crate::bindings::ExternalInputParser
5443{
5444 fn into_into_dart(self) -> FrbWrapper<crate::bindings::ExternalInputParser> {
5445 self.into()
5446 }
5447}
5448impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesRequest {
5450 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5451 [self.swap_id.into_into_dart().into_dart()].into_dart()
5452 }
5453}
5454impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5455 for crate::model::FetchPaymentProposedFeesRequest
5456{
5457}
5458impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesRequest>
5459 for crate::model::FetchPaymentProposedFeesRequest
5460{
5461 fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesRequest {
5462 self
5463 }
5464}
5465impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesResponse {
5467 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5468 [
5469 self.swap_id.into_into_dart().into_dart(),
5470 self.fees_sat.into_into_dart().into_dart(),
5471 self.payer_amount_sat.into_into_dart().into_dart(),
5472 self.receiver_amount_sat.into_into_dart().into_dart(),
5473 ]
5474 .into_dart()
5475 }
5476}
5477impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5478 for crate::model::FetchPaymentProposedFeesResponse
5479{
5480}
5481impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesResponse>
5482 for crate::model::FetchPaymentProposedFeesResponse
5483{
5484 fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesResponse {
5485 self
5486 }
5487}
5488impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::FiatCurrency> {
5490 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5491 [
5492 self.0.id.into_into_dart().into_dart(),
5493 self.0.info.into_into_dart().into_dart(),
5494 ]
5495 .into_dart()
5496 }
5497}
5498impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5499 for FrbWrapper<crate::bindings::FiatCurrency>
5500{
5501}
5502impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::FiatCurrency>>
5503 for crate::bindings::FiatCurrency
5504{
5505 fn into_into_dart(self) -> FrbWrapper<crate::bindings::FiatCurrency> {
5506 self.into()
5507 }
5508}
5509impl flutter_rust_bridge::IntoDart for crate::model::GetInfoResponse {
5511 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5512 [
5513 self.wallet_info.into_into_dart().into_dart(),
5514 self.blockchain_info.into_into_dart().into_dart(),
5515 ]
5516 .into_dart()
5517 }
5518}
5519impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::GetInfoResponse {}
5520impl flutter_rust_bridge::IntoIntoDart<crate::model::GetInfoResponse>
5521 for crate::model::GetInfoResponse
5522{
5523 fn into_into_dart(self) -> crate::model::GetInfoResponse {
5524 self
5525 }
5526}
5527impl flutter_rust_bridge::IntoDart for crate::model::GetPaymentRequest {
5529 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5530 match self {
5531 crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
5532 [0.into_dart(), payment_hash.into_into_dart().into_dart()].into_dart()
5533 }
5534 crate::model::GetPaymentRequest::SwapId { swap_id } => {
5535 [1.into_dart(), swap_id.into_into_dart().into_dart()].into_dart()
5536 }
5537 _ => {
5538 unimplemented!("");
5539 }
5540 }
5541 }
5542}
5543impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5544 for crate::model::GetPaymentRequest
5545{
5546}
5547impl flutter_rust_bridge::IntoIntoDart<crate::model::GetPaymentRequest>
5548 for crate::model::GetPaymentRequest
5549{
5550 fn into_into_dart(self) -> crate::model::GetPaymentRequest {
5551 self
5552 }
5553}
5554impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::InputType> {
5556 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5557 match self.0 {
5558 crate::bindings::InputType::BitcoinAddress { address } => {
5559 [0.into_dart(), address.into_into_dart().into_dart()].into_dart()
5560 }
5561 crate::bindings::InputType::LiquidAddress { address } => {
5562 [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5563 }
5564 crate::bindings::InputType::Bolt11 { invoice } => {
5565 [2.into_dart(), invoice.into_into_dart().into_dart()].into_dart()
5566 }
5567 crate::bindings::InputType::Bolt12Offer {
5568 offer,
5569 bip353_address,
5570 } => [
5571 3.into_dart(),
5572 offer.into_into_dart().into_dart(),
5573 bip353_address.into_into_dart().into_dart(),
5574 ]
5575 .into_dart(),
5576 crate::bindings::InputType::NodeId { node_id } => {
5577 [4.into_dart(), node_id.into_into_dart().into_dart()].into_dart()
5578 }
5579 crate::bindings::InputType::Url { url } => {
5580 [5.into_dart(), url.into_into_dart().into_dart()].into_dart()
5581 }
5582 crate::bindings::InputType::LnUrlPay {
5583 data,
5584 bip353_address,
5585 } => [
5586 6.into_dart(),
5587 data.into_into_dart().into_dart(),
5588 bip353_address.into_into_dart().into_dart(),
5589 ]
5590 .into_dart(),
5591 crate::bindings::InputType::LnUrlWithdraw { data } => {
5592 [7.into_dart(), data.into_into_dart().into_dart()].into_dart()
5593 }
5594 crate::bindings::InputType::LnUrlAuth { data } => {
5595 [8.into_dart(), data.into_into_dart().into_dart()].into_dart()
5596 }
5597 crate::bindings::InputType::LnUrlError { data } => {
5598 [9.into_dart(), data.into_into_dart().into_dart()].into_dart()
5599 }
5600 _ => {
5601 unimplemented!("");
5602 }
5603 }
5604 }
5605}
5606impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5607 for FrbWrapper<crate::bindings::InputType>
5608{
5609}
5610impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::InputType>>
5611 for crate::bindings::InputType
5612{
5613 fn into_into_dart(self) -> FrbWrapper<crate::bindings::InputType> {
5614 self.into()
5615 }
5616}
5617impl flutter_rust_bridge::IntoDart for crate::model::LightningPaymentLimitsResponse {
5619 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5620 [
5621 self.send.into_into_dart().into_dart(),
5622 self.receive.into_into_dart().into_dart(),
5623 ]
5624 .into_dart()
5625 }
5626}
5627impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5628 for crate::model::LightningPaymentLimitsResponse
5629{
5630}
5631impl flutter_rust_bridge::IntoIntoDart<crate::model::LightningPaymentLimitsResponse>
5632 for crate::model::LightningPaymentLimitsResponse
5633{
5634 fn into_into_dart(self) -> crate::model::LightningPaymentLimitsResponse {
5635 self
5636 }
5637}
5638impl flutter_rust_bridge::IntoDart for crate::model::Limits {
5640 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5641 [
5642 self.min_sat.into_into_dart().into_dart(),
5643 self.max_sat.into_into_dart().into_dart(),
5644 self.max_zero_conf_sat.into_into_dart().into_dart(),
5645 ]
5646 .into_dart()
5647 }
5648}
5649impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Limits {}
5650impl flutter_rust_bridge::IntoIntoDart<crate::model::Limits> for crate::model::Limits {
5651 fn into_into_dart(self) -> crate::model::Limits {
5652 self
5653 }
5654}
5655impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LiquidAddressData> {
5657 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5658 [
5659 self.0.address.into_into_dart().into_dart(),
5660 self.0.network.into_into_dart().into_dart(),
5661 self.0.asset_id.into_into_dart().into_dart(),
5662 self.0.amount.into_into_dart().into_dart(),
5663 self.0.amount_sat.into_into_dart().into_dart(),
5664 self.0.label.into_into_dart().into_dart(),
5665 self.0.message.into_into_dart().into_dart(),
5666 ]
5667 .into_dart()
5668 }
5669}
5670impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5671 for FrbWrapper<crate::bindings::LiquidAddressData>
5672{
5673}
5674impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LiquidAddressData>>
5675 for crate::bindings::LiquidAddressData
5676{
5677 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LiquidAddressData> {
5678 self.into()
5679 }
5680}
5681impl flutter_rust_bridge::IntoDart for crate::model::LiquidNetwork {
5683 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5684 match self {
5685 Self::Mainnet => 0.into_dart(),
5686 Self::Testnet => 1.into_dart(),
5687 Self::Regtest => 2.into_dart(),
5688 _ => unreachable!(),
5689 }
5690 }
5691}
5692impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LiquidNetwork {}
5693impl flutter_rust_bridge::IntoIntoDart<crate::model::LiquidNetwork>
5694 for crate::model::LiquidNetwork
5695{
5696 fn into_into_dart(self) -> crate::model::LiquidNetwork {
5697 self
5698 }
5699}
5700impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentDetails {
5702 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5703 match self {
5704 crate::model::ListPaymentDetails::Liquid {
5705 asset_id,
5706 destination,
5707 } => [
5708 0.into_dart(),
5709 asset_id.into_into_dart().into_dart(),
5710 destination.into_into_dart().into_dart(),
5711 ]
5712 .into_dart(),
5713 crate::model::ListPaymentDetails::Bitcoin { address } => {
5714 [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5715 }
5716 _ => {
5717 unimplemented!("");
5718 }
5719 }
5720 }
5721}
5722impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5723 for crate::model::ListPaymentDetails
5724{
5725}
5726impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentDetails>
5727 for crate::model::ListPaymentDetails
5728{
5729 fn into_into_dart(self) -> crate::model::ListPaymentDetails {
5730 self
5731 }
5732}
5733impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentsRequest {
5735 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5736 [
5737 self.filters.into_into_dart().into_dart(),
5738 self.states.into_into_dart().into_dart(),
5739 self.from_timestamp.into_into_dart().into_dart(),
5740 self.to_timestamp.into_into_dart().into_dart(),
5741 self.offset.into_into_dart().into_dart(),
5742 self.limit.into_into_dart().into_dart(),
5743 self.details.into_into_dart().into_dart(),
5744 self.sort_ascending.into_into_dart().into_dart(),
5745 ]
5746 .into_dart()
5747 }
5748}
5749impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5750 for crate::model::ListPaymentsRequest
5751{
5752}
5753impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentsRequest>
5754 for crate::model::ListPaymentsRequest
5755{
5756 fn into_into_dart(self) -> crate::model::ListPaymentsRequest {
5757 self
5758 }
5759}
5760impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNInvoice> {
5762 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5763 [
5764 self.0.bolt11.into_into_dart().into_dart(),
5765 self.0.network.into_into_dart().into_dart(),
5766 self.0.payee_pubkey.into_into_dart().into_dart(),
5767 self.0.payment_hash.into_into_dart().into_dart(),
5768 self.0.description.into_into_dart().into_dart(),
5769 self.0.description_hash.into_into_dart().into_dart(),
5770 self.0.amount_msat.into_into_dart().into_dart(),
5771 self.0.timestamp.into_into_dart().into_dart(),
5772 self.0.expiry.into_into_dart().into_dart(),
5773 self.0.routing_hints.into_into_dart().into_dart(),
5774 self.0.payment_secret.into_into_dart().into_dart(),
5775 self.0
5776 .min_final_cltv_expiry_delta
5777 .into_into_dart()
5778 .into_dart(),
5779 ]
5780 .into_dart()
5781 }
5782}
5783impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5784 for FrbWrapper<crate::bindings::LNInvoice>
5785{
5786}
5787impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNInvoice>>
5788 for crate::bindings::LNInvoice
5789{
5790 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNInvoice> {
5791 self.into()
5792 }
5793}
5794impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNOffer> {
5796 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5797 [
5798 self.0.offer.into_into_dart().into_dart(),
5799 self.0.chains.into_into_dart().into_dart(),
5800 self.0.min_amount.into_into_dart().into_dart(),
5801 self.0.description.into_into_dart().into_dart(),
5802 self.0.absolute_expiry.into_into_dart().into_dart(),
5803 self.0.issuer.into_into_dart().into_dart(),
5804 self.0.signing_pubkey.into_into_dart().into_dart(),
5805 self.0.paths.into_into_dart().into_dart(),
5806 ]
5807 .into_dart()
5808 }
5809}
5810impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5811 for FrbWrapper<crate::bindings::LNOffer>
5812{
5813}
5814impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNOffer>>
5815 for crate::bindings::LNOffer
5816{
5817 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNOffer> {
5818 self.into()
5819 }
5820}
5821impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5823 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5824 [self.0.blinded_hops.into_into_dart().into_dart()].into_dart()
5825 }
5826}
5827impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5828 for FrbWrapper<crate::bindings::LnOfferBlindedPath>
5829{
5830}
5831impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnOfferBlindedPath>>
5832 for crate::bindings::LnOfferBlindedPath
5833{
5834 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5835 self.into()
5836 }
5837}
5838impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlAuthError {
5840 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5841 match self {
5842 crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
5843 [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
5844 }
5845 crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
5846 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5847 }
5848 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
5849 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5850 }
5851 _ => {
5852 unimplemented!("");
5853 }
5854 }
5855 }
5856}
5857impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5858 for crate::bindings::duplicates::LnUrlAuthError
5859{
5860}
5861impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlAuthError>
5862 for crate::bindings::duplicates::LnUrlAuthError
5863{
5864 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlAuthError {
5865 self
5866 }
5867}
5868impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5870 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5871 [
5872 self.0.k1.into_into_dart().into_dart(),
5873 self.0.action.into_into_dart().into_dart(),
5874 self.0.domain.into_into_dart().into_dart(),
5875 self.0.url.into_into_dart().into_dart(),
5876 ]
5877 .into_dart()
5878 }
5879}
5880impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5881 for FrbWrapper<crate::bindings::LnUrlAuthRequestData>
5882{
5883}
5884impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlAuthRequestData>>
5885 for crate::bindings::LnUrlAuthRequestData
5886{
5887 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5888 self.into()
5889 }
5890}
5891impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlCallbackStatus {
5893 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5894 match self {
5895 crate::bindings::duplicates::LnUrlCallbackStatus::Ok => [0.into_dart()].into_dart(),
5896 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
5897 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
5898 }
5899 _ => {
5900 unimplemented!("");
5901 }
5902 }
5903 }
5904}
5905impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5906 for crate::bindings::duplicates::LnUrlCallbackStatus
5907{
5908}
5909impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlCallbackStatus>
5910 for crate::bindings::duplicates::LnUrlCallbackStatus
5911{
5912 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
5913 self
5914 }
5915}
5916impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlErrorData> {
5918 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5919 [self.0.reason.into_into_dart().into_dart()].into_dart()
5920 }
5921}
5922impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5923 for FrbWrapper<crate::bindings::LnUrlErrorData>
5924{
5925}
5926impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlErrorData>>
5927 for crate::bindings::LnUrlErrorData
5928{
5929 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlErrorData> {
5930 self.into()
5931 }
5932}
5933impl flutter_rust_bridge::IntoDart for crate::model::LnUrlInfo {
5935 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5936 [
5937 self.ln_address.into_into_dart().into_dart(),
5938 self.lnurl_pay_comment.into_into_dart().into_dart(),
5939 self.lnurl_pay_domain.into_into_dart().into_dart(),
5940 self.lnurl_pay_metadata.into_into_dart().into_dart(),
5941 self.lnurl_pay_success_action.into_into_dart().into_dart(),
5942 self.lnurl_pay_unprocessed_success_action
5943 .into_into_dart()
5944 .into_dart(),
5945 self.lnurl_withdraw_endpoint.into_into_dart().into_dart(),
5946 ]
5947 .into_dart()
5948 }
5949}
5950impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlInfo {}
5951impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlInfo> for crate::model::LnUrlInfo {
5952 fn into_into_dart(self) -> crate::model::LnUrlInfo {
5953 self
5954 }
5955}
5956impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlPayError {
5958 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5959 match self {
5960 crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => [0.into_dart()].into_dart(),
5961 crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
5962 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5963 }
5964 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
5965 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5966 }
5967 crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
5968 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
5969 }
5970 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
5971 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
5972 }
5973 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
5974 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
5975 }
5976 crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
5977 [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
5978 }
5979 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
5980 [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
5981 }
5982 crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
5983 [8.into_dart(), err.into_into_dart().into_dart()].into_dart()
5984 }
5985 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
5986 [9.into_dart(), err.into_into_dart().into_dart()].into_dart()
5987 }
5988 crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
5989 [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
5990 }
5991 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
5992 [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
5993 }
5994 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
5995 [12.into_dart(), err.into_into_dart().into_dart()].into_dart()
5996 }
5997 _ => {
5998 unimplemented!("");
5999 }
6000 }
6001 }
6002}
6003impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6004 for crate::bindings::duplicates::LnUrlPayError
6005{
6006}
6007impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlPayError>
6008 for crate::bindings::duplicates::LnUrlPayError
6009{
6010 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlPayError {
6011 self
6012 }
6013}
6014impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6016 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6017 [
6018 self.0.payment_hash.into_into_dart().into_dart(),
6019 self.0.reason.into_into_dart().into_dart(),
6020 ]
6021 .into_dart()
6022 }
6023}
6024impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6025 for FrbWrapper<crate::bindings::LnUrlPayErrorData>
6026{
6027}
6028impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayErrorData>>
6029 for crate::bindings::LnUrlPayErrorData
6030{
6031 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6032 self.into()
6033 }
6034}
6035impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayRequest {
6037 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6038 [self.prepare_response.into_into_dart().into_dart()].into_dart()
6039 }
6040}
6041impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayRequest {}
6042impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayRequest>
6043 for crate::model::LnUrlPayRequest
6044{
6045 fn into_into_dart(self) -> crate::model::LnUrlPayRequest {
6046 self
6047 }
6048}
6049impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6051 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6052 [
6053 self.0.callback.into_into_dart().into_dart(),
6054 self.0.min_sendable.into_into_dart().into_dart(),
6055 self.0.max_sendable.into_into_dart().into_dart(),
6056 self.0.metadata_str.into_into_dart().into_dart(),
6057 self.0.comment_allowed.into_into_dart().into_dart(),
6058 self.0.domain.into_into_dart().into_dart(),
6059 self.0.allows_nostr.into_into_dart().into_dart(),
6060 self.0.nostr_pubkey.into_into_dart().into_dart(),
6061 self.0.ln_address.into_into_dart().into_dart(),
6062 ]
6063 .into_dart()
6064 }
6065}
6066impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6067 for FrbWrapper<crate::bindings::LnUrlPayRequestData>
6068{
6069}
6070impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayRequestData>>
6071 for crate::bindings::LnUrlPayRequestData
6072{
6073 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6074 self.into()
6075 }
6076}
6077impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayResult {
6079 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6080 match self {
6081 crate::model::LnUrlPayResult::EndpointSuccess { data } => {
6082 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6083 }
6084 crate::model::LnUrlPayResult::EndpointError { data } => {
6085 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6086 }
6087 crate::model::LnUrlPayResult::PayError { data } => {
6088 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6089 }
6090 _ => {
6091 unimplemented!("");
6092 }
6093 }
6094 }
6095}
6096impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayResult {}
6097impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayResult>
6098 for crate::model::LnUrlPayResult
6099{
6100 fn into_into_dart(self) -> crate::model::LnUrlPayResult {
6101 self
6102 }
6103}
6104impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPaySuccessData {
6106 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6107 [
6108 self.payment.into_into_dart().into_dart(),
6109 self.success_action.into_into_dart().into_dart(),
6110 ]
6111 .into_dart()
6112 }
6113}
6114impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6115 for crate::model::LnUrlPaySuccessData
6116{
6117}
6118impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPaySuccessData>
6119 for crate::model::LnUrlPaySuccessData
6120{
6121 fn into_into_dart(self) -> crate::model::LnUrlPaySuccessData {
6122 self
6123 }
6124}
6125impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawError {
6127 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6128 match self {
6129 crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
6130 [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
6131 }
6132 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
6133 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
6134 }
6135 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
6136 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
6137 }
6138 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
6139 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
6140 }
6141 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
6142 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6143 }
6144 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
6145 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6146 }
6147 _ => {
6148 unimplemented!("");
6149 }
6150 }
6151 }
6152}
6153impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6154 for crate::bindings::duplicates::LnUrlWithdrawError
6155{
6156}
6157impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawError>
6158 for crate::bindings::duplicates::LnUrlWithdrawError
6159{
6160 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
6161 self
6162 }
6163}
6164impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6166 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6167 [
6168 self.0.data.into_into_dart().into_dart(),
6169 self.0.amount_msat.into_into_dart().into_dart(),
6170 self.0.description.into_into_dart().into_dart(),
6171 ]
6172 .into_dart()
6173 }
6174}
6175impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6176 for FrbWrapper<crate::bindings::LnUrlWithdrawRequest>
6177{
6178}
6179impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequest>>
6180 for crate::bindings::LnUrlWithdrawRequest
6181{
6182 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6183 self.into()
6184 }
6185}
6186impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6188 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6189 [
6190 self.0.callback.into_into_dart().into_dart(),
6191 self.0.k1.into_into_dart().into_dart(),
6192 self.0.default_description.into_into_dart().into_dart(),
6193 self.0.min_withdrawable.into_into_dart().into_dart(),
6194 self.0.max_withdrawable.into_into_dart().into_dart(),
6195 ]
6196 .into_dart()
6197 }
6198}
6199impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6200 for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>
6201{
6202}
6203impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>>
6204 for crate::bindings::LnUrlWithdrawRequestData
6205{
6206 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6207 self.into()
6208 }
6209}
6210impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawResult {
6212 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6213 match self {
6214 crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
6215 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6216 }
6217 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
6218 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6219 }
6220 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
6221 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6222 }
6223 _ => {
6224 unimplemented!("");
6225 }
6226 }
6227 }
6228}
6229impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6230 for crate::bindings::duplicates::LnUrlWithdrawResult
6231{
6232}
6233impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawResult>
6234 for crate::bindings::duplicates::LnUrlWithdrawResult
6235{
6236 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
6237 self
6238 }
6239}
6240impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6242 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6243 [self.invoice.into_into_dart().into_dart()].into_dart()
6244 }
6245}
6246impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6247 for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6248{
6249}
6250impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
6251 for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6252{
6253 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6254 self
6255 }
6256}
6257impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocaleOverrides> {
6259 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6260 [
6261 self.0.locale.into_into_dart().into_dart(),
6262 self.0.spacing.into_into_dart().into_dart(),
6263 self.0.symbol.into_into_dart().into_dart(),
6264 ]
6265 .into_dart()
6266 }
6267}
6268impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6269 for FrbWrapper<crate::bindings::LocaleOverrides>
6270{
6271}
6272impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocaleOverrides>>
6273 for crate::bindings::LocaleOverrides
6274{
6275 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocaleOverrides> {
6276 self.into()
6277 }
6278}
6279impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocalizedName> {
6281 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6282 [
6283 self.0.locale.into_into_dart().into_dart(),
6284 self.0.name.into_into_dart().into_dart(),
6285 ]
6286 .into_dart()
6287 }
6288}
6289impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6290 for FrbWrapper<crate::bindings::LocalizedName>
6291{
6292}
6293impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocalizedName>>
6294 for crate::bindings::LocalizedName
6295{
6296 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocalizedName> {
6297 self.into()
6298 }
6299}
6300impl flutter_rust_bridge::IntoDart for crate::model::LogEntry {
6302 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6303 [
6304 self.line.into_into_dart().into_dart(),
6305 self.level.into_into_dart().into_dart(),
6306 ]
6307 .into_dart()
6308 }
6309}
6310impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LogEntry {}
6311impl flutter_rust_bridge::IntoIntoDart<crate::model::LogEntry> for crate::model::LogEntry {
6312 fn into_into_dart(self) -> crate::model::LogEntry {
6313 self
6314 }
6315}
6316impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::MessageSuccessActionData> {
6318 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6319 [self.0.message.into_into_dart().into_dart()].into_dart()
6320 }
6321}
6322impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6323 for FrbWrapper<crate::bindings::MessageSuccessActionData>
6324{
6325}
6326impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::MessageSuccessActionData>>
6327 for crate::bindings::MessageSuccessActionData
6328{
6329 fn into_into_dart(self) -> FrbWrapper<crate::bindings::MessageSuccessActionData> {
6330 self.into()
6331 }
6332}
6333impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Network> {
6335 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6336 match self.0 {
6337 crate::bindings::Network::Bitcoin => 0.into_dart(),
6338 crate::bindings::Network::Testnet => 1.into_dart(),
6339 crate::bindings::Network::Signet => 2.into_dart(),
6340 crate::bindings::Network::Regtest => 3.into_dart(),
6341 _ => unreachable!(),
6342 }
6343 }
6344}
6345impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6346 for FrbWrapper<crate::bindings::Network>
6347{
6348}
6349impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Network>>
6350 for crate::bindings::Network
6351{
6352 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Network> {
6353 self.into()
6354 }
6355}
6356impl flutter_rust_bridge::IntoDart for crate::model::OnchainPaymentLimitsResponse {
6358 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6359 [
6360 self.send.into_into_dart().into_dart(),
6361 self.receive.into_into_dart().into_dart(),
6362 ]
6363 .into_dart()
6364 }
6365}
6366impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6367 for crate::model::OnchainPaymentLimitsResponse
6368{
6369}
6370impl flutter_rust_bridge::IntoIntoDart<crate::model::OnchainPaymentLimitsResponse>
6371 for crate::model::OnchainPaymentLimitsResponse
6372{
6373 fn into_into_dart(self) -> crate::model::OnchainPaymentLimitsResponse {
6374 self
6375 }
6376}
6377impl flutter_rust_bridge::IntoDart for crate::model::PayAmount {
6379 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6380 match self {
6381 crate::model::PayAmount::Bitcoin {
6382 receiver_amount_sat,
6383 } => [
6384 0.into_dart(),
6385 receiver_amount_sat.into_into_dart().into_dart(),
6386 ]
6387 .into_dart(),
6388 crate::model::PayAmount::Asset {
6389 asset_id,
6390 receiver_amount,
6391 estimate_asset_fees,
6392 } => [
6393 1.into_dart(),
6394 asset_id.into_into_dart().into_dart(),
6395 receiver_amount.into_into_dart().into_dart(),
6396 estimate_asset_fees.into_into_dart().into_dart(),
6397 ]
6398 .into_dart(),
6399 crate::model::PayAmount::Drain => [2.into_dart()].into_dart(),
6400 _ => {
6401 unimplemented!("");
6402 }
6403 }
6404 }
6405}
6406impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PayAmount {}
6407impl flutter_rust_bridge::IntoIntoDart<crate::model::PayAmount> for crate::model::PayAmount {
6408 fn into_into_dart(self) -> crate::model::PayAmount {
6409 self
6410 }
6411}
6412impl flutter_rust_bridge::IntoDart for crate::model::PayOnchainRequest {
6414 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6415 [
6416 self.address.into_into_dart().into_dart(),
6417 self.prepare_response.into_into_dart().into_dart(),
6418 ]
6419 .into_dart()
6420 }
6421}
6422impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6423 for crate::model::PayOnchainRequest
6424{
6425}
6426impl flutter_rust_bridge::IntoIntoDart<crate::model::PayOnchainRequest>
6427 for crate::model::PayOnchainRequest
6428{
6429 fn into_into_dart(self) -> crate::model::PayOnchainRequest {
6430 self
6431 }
6432}
6433impl flutter_rust_bridge::IntoDart for crate::model::Payment {
6435 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6436 [
6437 self.destination.into_into_dart().into_dart(),
6438 self.tx_id.into_into_dart().into_dart(),
6439 self.unblinding_data.into_into_dart().into_dart(),
6440 self.timestamp.into_into_dart().into_dart(),
6441 self.amount_sat.into_into_dart().into_dart(),
6442 self.fees_sat.into_into_dart().into_dart(),
6443 self.swapper_fees_sat.into_into_dart().into_dart(),
6444 self.payment_type.into_into_dart().into_dart(),
6445 self.status.into_into_dart().into_dart(),
6446 self.details.into_into_dart().into_dart(),
6447 ]
6448 .into_dart()
6449 }
6450}
6451impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Payment {}
6452impl flutter_rust_bridge::IntoIntoDart<crate::model::Payment> for crate::model::Payment {
6453 fn into_into_dart(self) -> crate::model::Payment {
6454 self
6455 }
6456}
6457impl flutter_rust_bridge::IntoDart for crate::model::PaymentDetails {
6459 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6460 match self {
6461 crate::model::PaymentDetails::Lightning {
6462 swap_id,
6463 description,
6464 liquid_expiration_blockheight,
6465 preimage,
6466 invoice,
6467 bolt12_offer,
6468 payment_hash,
6469 destination_pubkey,
6470 lnurl_info,
6471 bip353_address,
6472 claim_tx_id,
6473 refund_tx_id,
6474 refund_tx_amount_sat,
6475 } => [
6476 0.into_dart(),
6477 swap_id.into_into_dart().into_dart(),
6478 description.into_into_dart().into_dart(),
6479 liquid_expiration_blockheight.into_into_dart().into_dart(),
6480 preimage.into_into_dart().into_dart(),
6481 invoice.into_into_dart().into_dart(),
6482 bolt12_offer.into_into_dart().into_dart(),
6483 payment_hash.into_into_dart().into_dart(),
6484 destination_pubkey.into_into_dart().into_dart(),
6485 lnurl_info.into_into_dart().into_dart(),
6486 bip353_address.into_into_dart().into_dart(),
6487 claim_tx_id.into_into_dart().into_dart(),
6488 refund_tx_id.into_into_dart().into_dart(),
6489 refund_tx_amount_sat.into_into_dart().into_dart(),
6490 ]
6491 .into_dart(),
6492 crate::model::PaymentDetails::Liquid {
6493 destination,
6494 description,
6495 asset_id,
6496 asset_info,
6497 lnurl_info,
6498 bip353_address,
6499 } => [
6500 1.into_dart(),
6501 destination.into_into_dart().into_dart(),
6502 description.into_into_dart().into_dart(),
6503 asset_id.into_into_dart().into_dart(),
6504 asset_info.into_into_dart().into_dart(),
6505 lnurl_info.into_into_dart().into_dart(),
6506 bip353_address.into_into_dart().into_dart(),
6507 ]
6508 .into_dart(),
6509 crate::model::PaymentDetails::Bitcoin {
6510 swap_id,
6511 description,
6512 auto_accepted_fees,
6513 liquid_expiration_blockheight,
6514 bitcoin_expiration_blockheight,
6515 claim_tx_id,
6516 refund_tx_id,
6517 refund_tx_amount_sat,
6518 } => [
6519 2.into_dart(),
6520 swap_id.into_into_dart().into_dart(),
6521 description.into_into_dart().into_dart(),
6522 auto_accepted_fees.into_into_dart().into_dart(),
6523 liquid_expiration_blockheight.into_into_dart().into_dart(),
6524 bitcoin_expiration_blockheight.into_into_dart().into_dart(),
6525 claim_tx_id.into_into_dart().into_dart(),
6526 refund_tx_id.into_into_dart().into_dart(),
6527 refund_tx_amount_sat.into_into_dart().into_dart(),
6528 ]
6529 .into_dart(),
6530 _ => {
6531 unimplemented!("");
6532 }
6533 }
6534 }
6535}
6536impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentDetails {}
6537impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentDetails>
6538 for crate::model::PaymentDetails
6539{
6540 fn into_into_dart(self) -> crate::model::PaymentDetails {
6541 self
6542 }
6543}
6544impl flutter_rust_bridge::IntoDart for crate::error::PaymentError {
6546 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6547 match self {
6548 crate::error::PaymentError::AlreadyClaimed => [0.into_dart()].into_dart(),
6549 crate::error::PaymentError::AlreadyPaid => [1.into_dart()].into_dart(),
6550 crate::error::PaymentError::PaymentInProgress => [2.into_dart()].into_dart(),
6551 crate::error::PaymentError::AmountOutOfRange { min, max } => [
6552 3.into_dart(),
6553 min.into_into_dart().into_dart(),
6554 max.into_into_dart().into_dart(),
6555 ]
6556 .into_dart(),
6557 crate::error::PaymentError::AmountMissing { err } => {
6558 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6559 }
6560 crate::error::PaymentError::AssetError { err } => {
6561 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6562 }
6563 crate::error::PaymentError::InvalidNetwork { err } => {
6564 [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
6565 }
6566 crate::error::PaymentError::Generic { err } => {
6567 [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
6568 }
6569 crate::error::PaymentError::InvalidOrExpiredFees => [8.into_dart()].into_dart(),
6570 crate::error::PaymentError::InsufficientFunds => [9.into_dart()].into_dart(),
6571 crate::error::PaymentError::InvalidDescription { err } => {
6572 [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6573 }
6574 crate::error::PaymentError::InvalidInvoice { err } => {
6575 [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6576 }
6577 crate::error::PaymentError::InvalidPreimage => [12.into_dart()].into_dart(),
6578 crate::error::PaymentError::PairsNotFound => [13.into_dart()].into_dart(),
6579 crate::error::PaymentError::PaymentTimeout => [14.into_dart()].into_dart(),
6580 crate::error::PaymentError::PersistError => [15.into_dart()].into_dart(),
6581 crate::error::PaymentError::ReceiveError { err } => {
6582 [16.into_dart(), err.into_into_dart().into_dart()].into_dart()
6583 }
6584 crate::error::PaymentError::Refunded { err, refund_tx_id } => [
6585 17.into_dart(),
6586 err.into_into_dart().into_dart(),
6587 refund_tx_id.into_into_dart().into_dart(),
6588 ]
6589 .into_dart(),
6590 crate::error::PaymentError::SelfTransferNotSupported => [18.into_dart()].into_dart(),
6591 crate::error::PaymentError::SendError { err } => {
6592 [19.into_dart(), err.into_into_dart().into_dart()].into_dart()
6593 }
6594 crate::error::PaymentError::SignerError { err } => {
6595 [20.into_dart(), err.into_into_dart().into_dart()].into_dart()
6596 }
6597 _ => {
6598 unimplemented!("");
6599 }
6600 }
6601 }
6602}
6603impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::PaymentError {}
6604impl flutter_rust_bridge::IntoIntoDart<crate::error::PaymentError> for crate::error::PaymentError {
6605 fn into_into_dart(self) -> crate::error::PaymentError {
6606 self
6607 }
6608}
6609impl flutter_rust_bridge::IntoDart for crate::model::PaymentMethod {
6611 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6612 match self {
6613 Self::Lightning => 0.into_dart(),
6614 Self::Bolt11Invoice => 1.into_dart(),
6615 Self::Bolt12Offer => 2.into_dart(),
6616 Self::BitcoinAddress => 3.into_dart(),
6617 Self::LiquidAddress => 4.into_dart(),
6618 _ => unreachable!(),
6619 }
6620 }
6621}
6622impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentMethod {}
6623impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentMethod>
6624 for crate::model::PaymentMethod
6625{
6626 fn into_into_dart(self) -> crate::model::PaymentMethod {
6627 self
6628 }
6629}
6630impl flutter_rust_bridge::IntoDart for crate::model::PaymentState {
6632 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6633 match self {
6634 Self::Created => 0.into_dart(),
6635 Self::Pending => 1.into_dart(),
6636 Self::Complete => 2.into_dart(),
6637 Self::Failed => 3.into_dart(),
6638 Self::TimedOut => 4.into_dart(),
6639 Self::Refundable => 5.into_dart(),
6640 Self::RefundPending => 6.into_dart(),
6641 Self::WaitingFeeAcceptance => 7.into_dart(),
6642 _ => unreachable!(),
6643 }
6644 }
6645}
6646impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentState {}
6647impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentState> for crate::model::PaymentState {
6648 fn into_into_dart(self) -> crate::model::PaymentState {
6649 self
6650 }
6651}
6652impl flutter_rust_bridge::IntoDart for crate::model::PaymentType {
6654 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6655 match self {
6656 Self::Receive => 0.into_dart(),
6657 Self::Send => 1.into_dart(),
6658 _ => unreachable!(),
6659 }
6660 }
6661}
6662impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentType {}
6663impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentType> for crate::model::PaymentType {
6664 fn into_into_dart(self) -> crate::model::PaymentType {
6665 self
6666 }
6667}
6668impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinRequest {
6670 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6671 [
6672 self.provider.into_into_dart().into_dart(),
6673 self.amount_sat.into_into_dart().into_dart(),
6674 ]
6675 .into_dart()
6676 }
6677}
6678impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6679 for crate::model::PrepareBuyBitcoinRequest
6680{
6681}
6682impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinRequest>
6683 for crate::model::PrepareBuyBitcoinRequest
6684{
6685 fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinRequest {
6686 self
6687 }
6688}
6689impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinResponse {
6691 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6692 [
6693 self.provider.into_into_dart().into_dart(),
6694 self.amount_sat.into_into_dart().into_dart(),
6695 self.fees_sat.into_into_dart().into_dart(),
6696 ]
6697 .into_dart()
6698 }
6699}
6700impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6701 for crate::model::PrepareBuyBitcoinResponse
6702{
6703}
6704impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinResponse>
6705 for crate::model::PrepareBuyBitcoinResponse
6706{
6707 fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinResponse {
6708 self
6709 }
6710}
6711impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayRequest {
6713 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6714 [
6715 self.data.into_into_dart().into_dart(),
6716 self.amount.into_into_dart().into_dart(),
6717 self.bip353_address.into_into_dart().into_dart(),
6718 self.comment.into_into_dart().into_dart(),
6719 self.validate_success_action_url
6720 .into_into_dart()
6721 .into_dart(),
6722 ]
6723 .into_dart()
6724 }
6725}
6726impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6727 for crate::model::PrepareLnUrlPayRequest
6728{
6729}
6730impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayRequest>
6731 for crate::model::PrepareLnUrlPayRequest
6732{
6733 fn into_into_dart(self) -> crate::model::PrepareLnUrlPayRequest {
6734 self
6735 }
6736}
6737impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayResponse {
6739 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6740 [
6741 self.destination.into_into_dart().into_dart(),
6742 self.fees_sat.into_into_dart().into_dart(),
6743 self.data.into_into_dart().into_dart(),
6744 self.comment.into_into_dart().into_dart(),
6745 self.success_action.into_into_dart().into_dart(),
6746 ]
6747 .into_dart()
6748 }
6749}
6750impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6751 for crate::model::PrepareLnUrlPayResponse
6752{
6753}
6754impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayResponse>
6755 for crate::model::PrepareLnUrlPayResponse
6756{
6757 fn into_into_dart(self) -> crate::model::PrepareLnUrlPayResponse {
6758 self
6759 }
6760}
6761impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainRequest {
6763 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6764 [
6765 self.amount.into_into_dart().into_dart(),
6766 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6767 ]
6768 .into_dart()
6769 }
6770}
6771impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6772 for crate::model::PreparePayOnchainRequest
6773{
6774}
6775impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainRequest>
6776 for crate::model::PreparePayOnchainRequest
6777{
6778 fn into_into_dart(self) -> crate::model::PreparePayOnchainRequest {
6779 self
6780 }
6781}
6782impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainResponse {
6784 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6785 [
6786 self.receiver_amount_sat.into_into_dart().into_dart(),
6787 self.claim_fees_sat.into_into_dart().into_dart(),
6788 self.total_fees_sat.into_into_dart().into_dart(),
6789 ]
6790 .into_dart()
6791 }
6792}
6793impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6794 for crate::model::PreparePayOnchainResponse
6795{
6796}
6797impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainResponse>
6798 for crate::model::PreparePayOnchainResponse
6799{
6800 fn into_into_dart(self) -> crate::model::PreparePayOnchainResponse {
6801 self
6802 }
6803}
6804impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveRequest {
6806 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6807 [
6808 self.payment_method.into_into_dart().into_dart(),
6809 self.amount.into_into_dart().into_dart(),
6810 ]
6811 .into_dart()
6812 }
6813}
6814impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6815 for crate::model::PrepareReceiveRequest
6816{
6817}
6818impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveRequest>
6819 for crate::model::PrepareReceiveRequest
6820{
6821 fn into_into_dart(self) -> crate::model::PrepareReceiveRequest {
6822 self
6823 }
6824}
6825impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveResponse {
6827 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6828 [
6829 self.payment_method.into_into_dart().into_dart(),
6830 self.fees_sat.into_into_dart().into_dart(),
6831 self.amount.into_into_dart().into_dart(),
6832 self.min_payer_amount_sat.into_into_dart().into_dart(),
6833 self.max_payer_amount_sat.into_into_dart().into_dart(),
6834 self.swapper_feerate.into_into_dart().into_dart(),
6835 ]
6836 .into_dart()
6837 }
6838}
6839impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6840 for crate::model::PrepareReceiveResponse
6841{
6842}
6843impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveResponse>
6844 for crate::model::PrepareReceiveResponse
6845{
6846 fn into_into_dart(self) -> crate::model::PrepareReceiveResponse {
6847 self
6848 }
6849}
6850impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundRequest {
6852 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6853 [
6854 self.swap_address.into_into_dart().into_dart(),
6855 self.refund_address.into_into_dart().into_dart(),
6856 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6857 ]
6858 .into_dart()
6859 }
6860}
6861impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6862 for crate::model::PrepareRefundRequest
6863{
6864}
6865impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundRequest>
6866 for crate::model::PrepareRefundRequest
6867{
6868 fn into_into_dart(self) -> crate::model::PrepareRefundRequest {
6869 self
6870 }
6871}
6872impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundResponse {
6874 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6875 [
6876 self.tx_vsize.into_into_dart().into_dart(),
6877 self.tx_fee_sat.into_into_dart().into_dart(),
6878 self.last_refund_tx_id.into_into_dart().into_dart(),
6879 ]
6880 .into_dart()
6881 }
6882}
6883impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6884 for crate::model::PrepareRefundResponse
6885{
6886}
6887impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundResponse>
6888 for crate::model::PrepareRefundResponse
6889{
6890 fn into_into_dart(self) -> crate::model::PrepareRefundResponse {
6891 self
6892 }
6893}
6894impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendRequest {
6896 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6897 [
6898 self.destination.into_into_dart().into_dart(),
6899 self.amount.into_into_dart().into_dart(),
6900 ]
6901 .into_dart()
6902 }
6903}
6904impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6905 for crate::model::PrepareSendRequest
6906{
6907}
6908impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendRequest>
6909 for crate::model::PrepareSendRequest
6910{
6911 fn into_into_dart(self) -> crate::model::PrepareSendRequest {
6912 self
6913 }
6914}
6915impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendResponse {
6917 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6918 [
6919 self.destination.into_into_dart().into_dart(),
6920 self.fees_sat.into_into_dart().into_dart(),
6921 self.estimated_asset_fees.into_into_dart().into_dart(),
6922 ]
6923 .into_dart()
6924 }
6925}
6926impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6927 for crate::model::PrepareSendResponse
6928{
6929}
6930impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendResponse>
6931 for crate::model::PrepareSendResponse
6932{
6933 fn into_into_dart(self) -> crate::model::PrepareSendResponse {
6934 self
6935 }
6936}
6937impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Rate> {
6939 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6940 [
6941 self.0.coin.into_into_dart().into_dart(),
6942 self.0.value.into_into_dart().into_dart(),
6943 ]
6944 .into_dart()
6945 }
6946}
6947impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6948 for FrbWrapper<crate::bindings::Rate>
6949{
6950}
6951impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Rate>>
6952 for crate::bindings::Rate
6953{
6954 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Rate> {
6955 self.into()
6956 }
6957}
6958impl flutter_rust_bridge::IntoDart for crate::model::ReceiveAmount {
6960 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6961 match self {
6962 crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
6963 [0.into_dart(), payer_amount_sat.into_into_dart().into_dart()].into_dart()
6964 }
6965 crate::model::ReceiveAmount::Asset {
6966 asset_id,
6967 payer_amount,
6968 } => [
6969 1.into_dart(),
6970 asset_id.into_into_dart().into_dart(),
6971 payer_amount.into_into_dart().into_dart(),
6972 ]
6973 .into_dart(),
6974 _ => {
6975 unimplemented!("");
6976 }
6977 }
6978 }
6979}
6980impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ReceiveAmount {}
6981impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceiveAmount>
6982 for crate::model::ReceiveAmount
6983{
6984 fn into_into_dart(self) -> crate::model::ReceiveAmount {
6985 self
6986 }
6987}
6988impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentRequest {
6990 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6991 [
6992 self.prepare_response.into_into_dart().into_dart(),
6993 self.description.into_into_dart().into_dart(),
6994 self.use_description_hash.into_into_dart().into_dart(),
6995 ]
6996 .into_dart()
6997 }
6998}
6999impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7000 for crate::model::ReceivePaymentRequest
7001{
7002}
7003impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentRequest>
7004 for crate::model::ReceivePaymentRequest
7005{
7006 fn into_into_dart(self) -> crate::model::ReceivePaymentRequest {
7007 self
7008 }
7009}
7010impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentResponse {
7012 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7013 [self.destination.into_into_dart().into_dart()].into_dart()
7014 }
7015}
7016impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7017 for crate::model::ReceivePaymentResponse
7018{
7019}
7020impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentResponse>
7021 for crate::model::ReceivePaymentResponse
7022{
7023 fn into_into_dart(self) -> crate::model::ReceivePaymentResponse {
7024 self
7025 }
7026}
7027impl flutter_rust_bridge::IntoDart for crate::model::RecommendedFees {
7029 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7030 [
7031 self.fastest_fee.into_into_dart().into_dart(),
7032 self.half_hour_fee.into_into_dart().into_dart(),
7033 self.hour_fee.into_into_dart().into_dart(),
7034 self.economy_fee.into_into_dart().into_dart(),
7035 self.minimum_fee.into_into_dart().into_dart(),
7036 ]
7037 .into_dart()
7038 }
7039}
7040impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RecommendedFees {}
7041impl flutter_rust_bridge::IntoIntoDart<crate::model::RecommendedFees>
7042 for crate::model::RecommendedFees
7043{
7044 fn into_into_dart(self) -> crate::model::RecommendedFees {
7045 self
7046 }
7047}
7048impl flutter_rust_bridge::IntoDart for crate::model::RefundRequest {
7050 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7051 [
7052 self.swap_address.into_into_dart().into_dart(),
7053 self.refund_address.into_into_dart().into_dart(),
7054 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
7055 ]
7056 .into_dart()
7057 }
7058}
7059impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundRequest {}
7060impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundRequest>
7061 for crate::model::RefundRequest
7062{
7063 fn into_into_dart(self) -> crate::model::RefundRequest {
7064 self
7065 }
7066}
7067impl flutter_rust_bridge::IntoDart for crate::model::RefundResponse {
7069 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7070 [self.refund_tx_id.into_into_dart().into_dart()].into_dart()
7071 }
7072}
7073impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundResponse {}
7074impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundResponse>
7075 for crate::model::RefundResponse
7076{
7077 fn into_into_dart(self) -> crate::model::RefundResponse {
7078 self
7079 }
7080}
7081impl flutter_rust_bridge::IntoDart for crate::model::RefundableSwap {
7083 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7084 [
7085 self.swap_address.into_into_dart().into_dart(),
7086 self.timestamp.into_into_dart().into_dart(),
7087 self.amount_sat.into_into_dart().into_dart(),
7088 self.last_refund_tx_id.into_into_dart().into_dart(),
7089 ]
7090 .into_dart()
7091 }
7092}
7093impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundableSwap {}
7094impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundableSwap>
7095 for crate::model::RefundableSwap
7096{
7097 fn into_into_dart(self) -> crate::model::RefundableSwap {
7098 self
7099 }
7100}
7101impl flutter_rust_bridge::IntoDart for crate::model::RestoreRequest {
7103 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7104 [self.backup_path.into_into_dart().into_dart()].into_dart()
7105 }
7106}
7107impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RestoreRequest {}
7108impl flutter_rust_bridge::IntoIntoDart<crate::model::RestoreRequest>
7109 for crate::model::RestoreRequest
7110{
7111 fn into_into_dart(self) -> crate::model::RestoreRequest {
7112 self
7113 }
7114}
7115impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHint> {
7117 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7118 [self.0.hops.into_into_dart().into_dart()].into_dart()
7119 }
7120}
7121impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7122 for FrbWrapper<crate::bindings::RouteHint>
7123{
7124}
7125impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHint>>
7126 for crate::bindings::RouteHint
7127{
7128 fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHint> {
7129 self.into()
7130 }
7131}
7132impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHintHop> {
7134 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7135 [
7136 self.0.src_node_id.into_into_dart().into_dart(),
7137 self.0.short_channel_id.into_into_dart().into_dart(),
7138 self.0.fees_base_msat.into_into_dart().into_dart(),
7139 self.0
7140 .fees_proportional_millionths
7141 .into_into_dart()
7142 .into_dart(),
7143 self.0.cltv_expiry_delta.into_into_dart().into_dart(),
7144 self.0.htlc_minimum_msat.into_into_dart().into_dart(),
7145 self.0.htlc_maximum_msat.into_into_dart().into_dart(),
7146 ]
7147 .into_dart()
7148 }
7149}
7150impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7151 for FrbWrapper<crate::bindings::RouteHintHop>
7152{
7153}
7154impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHintHop>>
7155 for crate::bindings::RouteHintHop
7156{
7157 fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHintHop> {
7158 self.into()
7159 }
7160}
7161impl flutter_rust_bridge::IntoDart for crate::error::SdkError {
7163 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7164 match self {
7165 crate::error::SdkError::AlreadyStarted => [0.into_dart()].into_dart(),
7166 crate::error::SdkError::Generic { err } => {
7167 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
7168 }
7169 crate::error::SdkError::NotStarted => [2.into_dart()].into_dart(),
7170 crate::error::SdkError::ServiceConnectivity { err } => {
7171 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
7172 }
7173 _ => {
7174 unimplemented!("");
7175 }
7176 }
7177 }
7178}
7179impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::SdkError {}
7180impl flutter_rust_bridge::IntoIntoDart<crate::error::SdkError> for crate::error::SdkError {
7181 fn into_into_dart(self) -> crate::error::SdkError {
7182 self
7183 }
7184}
7185impl flutter_rust_bridge::IntoDart for crate::model::SdkEvent {
7187 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7188 match self {
7189 crate::model::SdkEvent::PaymentFailed { details } => {
7190 [0.into_dart(), details.into_into_dart().into_dart()].into_dart()
7191 }
7192 crate::model::SdkEvent::PaymentPending { details } => {
7193 [1.into_dart(), details.into_into_dart().into_dart()].into_dart()
7194 }
7195 crate::model::SdkEvent::PaymentRefundable { details } => {
7196 [2.into_dart(), details.into_into_dart().into_dart()].into_dart()
7197 }
7198 crate::model::SdkEvent::PaymentRefunded { details } => {
7199 [3.into_dart(), details.into_into_dart().into_dart()].into_dart()
7200 }
7201 crate::model::SdkEvent::PaymentRefundPending { details } => {
7202 [4.into_dart(), details.into_into_dart().into_dart()].into_dart()
7203 }
7204 crate::model::SdkEvent::PaymentSucceeded { details } => {
7205 [5.into_dart(), details.into_into_dart().into_dart()].into_dart()
7206 }
7207 crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
7208 [6.into_dart(), details.into_into_dart().into_dart()].into_dart()
7209 }
7210 crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
7211 [7.into_dart(), details.into_into_dart().into_dart()].into_dart()
7212 }
7213 crate::model::SdkEvent::Synced => [8.into_dart()].into_dart(),
7214 crate::model::SdkEvent::DataSynced {
7215 did_pull_new_records,
7216 } => [
7217 9.into_dart(),
7218 did_pull_new_records.into_into_dart().into_dart(),
7219 ]
7220 .into_dart(),
7221 _ => {
7222 unimplemented!("");
7223 }
7224 }
7225 }
7226}
7227impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SdkEvent {}
7228impl flutter_rust_bridge::IntoIntoDart<crate::model::SdkEvent> for crate::model::SdkEvent {
7229 fn into_into_dart(self) -> crate::model::SdkEvent {
7230 self
7231 }
7232}
7233impl flutter_rust_bridge::IntoDart for crate::model::SendDestination {
7235 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7236 match self {
7237 crate::model::SendDestination::LiquidAddress {
7238 address_data,
7239 bip353_address,
7240 } => [
7241 0.into_dart(),
7242 address_data.into_into_dart().into_dart(),
7243 bip353_address.into_into_dart().into_dart(),
7244 ]
7245 .into_dart(),
7246 crate::model::SendDestination::Bolt11 {
7247 invoice,
7248 bip353_address,
7249 } => [
7250 1.into_dart(),
7251 invoice.into_into_dart().into_dart(),
7252 bip353_address.into_into_dart().into_dart(),
7253 ]
7254 .into_dart(),
7255 crate::model::SendDestination::Bolt12 {
7256 offer,
7257 receiver_amount_sat,
7258 bip353_address,
7259 } => [
7260 2.into_dart(),
7261 offer.into_into_dart().into_dart(),
7262 receiver_amount_sat.into_into_dart().into_dart(),
7263 bip353_address.into_into_dart().into_dart(),
7264 ]
7265 .into_dart(),
7266 _ => {
7267 unimplemented!("");
7268 }
7269 }
7270 }
7271}
7272impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SendDestination {}
7273impl flutter_rust_bridge::IntoIntoDart<crate::model::SendDestination>
7274 for crate::model::SendDestination
7275{
7276 fn into_into_dart(self) -> crate::model::SendDestination {
7277 self
7278 }
7279}
7280impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentRequest {
7282 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7283 [
7284 self.prepare_response.into_into_dart().into_dart(),
7285 self.use_asset_fees.into_into_dart().into_dart(),
7286 ]
7287 .into_dart()
7288 }
7289}
7290impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7291 for crate::model::SendPaymentRequest
7292{
7293}
7294impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentRequest>
7295 for crate::model::SendPaymentRequest
7296{
7297 fn into_into_dart(self) -> crate::model::SendPaymentRequest {
7298 self
7299 }
7300}
7301impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentResponse {
7303 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7304 [self.payment.into_into_dart().into_dart()].into_dart()
7305 }
7306}
7307impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7308 for crate::model::SendPaymentResponse
7309{
7310}
7311impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentResponse>
7312 for crate::model::SendPaymentResponse
7313{
7314 fn into_into_dart(self) -> crate::model::SendPaymentResponse {
7315 self
7316 }
7317}
7318impl flutter_rust_bridge::IntoDart for crate::model::SignMessageRequest {
7320 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7321 [self.message.into_into_dart().into_dart()].into_dart()
7322 }
7323}
7324impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7325 for crate::model::SignMessageRequest
7326{
7327}
7328impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageRequest>
7329 for crate::model::SignMessageRequest
7330{
7331 fn into_into_dart(self) -> crate::model::SignMessageRequest {
7332 self
7333 }
7334}
7335impl flutter_rust_bridge::IntoDart for crate::model::SignMessageResponse {
7337 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7338 [self.signature.into_into_dart().into_dart()].into_dart()
7339 }
7340}
7341impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7342 for crate::model::SignMessageResponse
7343{
7344}
7345impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageResponse>
7346 for crate::model::SignMessageResponse
7347{
7348 fn into_into_dart(self) -> crate::model::SignMessageResponse {
7349 self
7350 }
7351}
7352impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessAction> {
7354 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7355 match self.0 {
7356 crate::bindings::SuccessAction::Aes { data } => {
7357 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
7358 }
7359 crate::bindings::SuccessAction::Message { data } => {
7360 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7361 }
7362 crate::bindings::SuccessAction::Url { data } => {
7363 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7364 }
7365 _ => {
7366 unimplemented!("");
7367 }
7368 }
7369 }
7370}
7371impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7372 for FrbWrapper<crate::bindings::SuccessAction>
7373{
7374}
7375impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessAction>>
7376 for crate::bindings::SuccessAction
7377{
7378 fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessAction> {
7379 self.into()
7380 }
7381}
7382impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessActionProcessed> {
7384 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7385 match self.0 {
7386 crate::bindings::SuccessActionProcessed::Aes { result } => {
7387 [0.into_dart(), result.into_into_dart().into_dart()].into_dart()
7388 }
7389 crate::bindings::SuccessActionProcessed::Message { data } => {
7390 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7391 }
7392 crate::bindings::SuccessActionProcessed::Url { data } => {
7393 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7394 }
7395 _ => {
7396 unimplemented!("");
7397 }
7398 }
7399 }
7400}
7401impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7402 for FrbWrapper<crate::bindings::SuccessActionProcessed>
7403{
7404}
7405impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessActionProcessed>>
7406 for crate::bindings::SuccessActionProcessed
7407{
7408 fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessActionProcessed> {
7409 self.into()
7410 }
7411}
7412impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Symbol> {
7414 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7415 [
7416 self.0.grapheme.into_into_dart().into_dart(),
7417 self.0.template.into_into_dart().into_dart(),
7418 self.0.rtl.into_into_dart().into_dart(),
7419 self.0.position.into_into_dart().into_dart(),
7420 ]
7421 .into_dart()
7422 }
7423}
7424impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7425 for FrbWrapper<crate::bindings::Symbol>
7426{
7427}
7428impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Symbol>>
7429 for crate::bindings::Symbol
7430{
7431 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Symbol> {
7432 self.into()
7433 }
7434}
7435impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::UrlSuccessActionData> {
7437 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7438 [
7439 self.0.description.into_into_dart().into_dart(),
7440 self.0.url.into_into_dart().into_dart(),
7441 self.0.matches_callback_domain.into_into_dart().into_dart(),
7442 ]
7443 .into_dart()
7444 }
7445}
7446impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7447 for FrbWrapper<crate::bindings::UrlSuccessActionData>
7448{
7449}
7450impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::UrlSuccessActionData>>
7451 for crate::bindings::UrlSuccessActionData
7452{
7453 fn into_into_dart(self) -> FrbWrapper<crate::bindings::UrlSuccessActionData> {
7454 self.into()
7455 }
7456}
7457impl flutter_rust_bridge::IntoDart for crate::model::WalletInfo {
7459 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7460 [
7461 self.balance_sat.into_into_dart().into_dart(),
7462 self.pending_send_sat.into_into_dart().into_dart(),
7463 self.pending_receive_sat.into_into_dart().into_dart(),
7464 self.fingerprint.into_into_dart().into_dart(),
7465 self.pubkey.into_into_dart().into_dart(),
7466 self.asset_balances.into_into_dart().into_dart(),
7467 ]
7468 .into_dart()
7469 }
7470}
7471impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::WalletInfo {}
7472impl flutter_rust_bridge::IntoIntoDart<crate::model::WalletInfo> for crate::model::WalletInfo {
7473 fn into_into_dart(self) -> crate::model::WalletInfo {
7474 self
7475 }
7476}
7477
7478impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
7479 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7481 <String>::sse_encode(format!("{:?}", self), serializer);
7482 }
7483}
7484
7485impl SseEncode for BindingLiquidSdk {
7486 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7488 <RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer);
7489 }
7490}
7491
7492impl SseEncode
7493 for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
7494{
7495 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7497 let (ptr, size) = self.sse_encode_raw();
7498 <usize>::sse_encode(ptr, serializer);
7499 <i32>::sse_encode(size, serializer);
7500 }
7501}
7502
7503impl SseEncode
7504 for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
7505{
7506 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7508 unimplemented!("")
7509 }
7510}
7511
7512impl SseEncode
7513 for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
7514{
7515 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7517 unimplemented!("")
7518 }
7519}
7520
7521impl SseEncode for String {
7522 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7524 <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
7525 }
7526}
7527
7528impl SseEncode for crate::model::AcceptPaymentProposedFeesRequest {
7529 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7531 <crate::model::FetchPaymentProposedFeesResponse>::sse_encode(self.response, serializer);
7532 }
7533}
7534
7535impl SseEncode for crate::bindings::AesSuccessActionData {
7536 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7538 <String>::sse_encode(self.description, serializer);
7539 <String>::sse_encode(self.ciphertext, serializer);
7540 <String>::sse_encode(self.iv, serializer);
7541 }
7542}
7543
7544impl SseEncode for crate::bindings::AesSuccessActionDataDecrypted {
7545 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7547 <String>::sse_encode(self.description, serializer);
7548 <String>::sse_encode(self.plaintext, serializer);
7549 }
7550}
7551
7552impl SseEncode for crate::bindings::AesSuccessActionDataResult {
7553 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7555 match self {
7556 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
7557 <i32>::sse_encode(0, serializer);
7558 <crate::bindings::AesSuccessActionDataDecrypted>::sse_encode(data, serializer);
7559 }
7560 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
7561 <i32>::sse_encode(1, serializer);
7562 <String>::sse_encode(reason, serializer);
7563 }
7564 _ => {
7565 unimplemented!("");
7566 }
7567 }
7568 }
7569}
7570
7571impl SseEncode for crate::bindings::Amount {
7572 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7574 match self {
7575 crate::bindings::Amount::Bitcoin { amount_msat } => {
7576 <i32>::sse_encode(0, serializer);
7577 <u64>::sse_encode(amount_msat, serializer);
7578 }
7579 crate::bindings::Amount::Currency {
7580 iso4217_code,
7581 fractional_amount,
7582 } => {
7583 <i32>::sse_encode(1, serializer);
7584 <String>::sse_encode(iso4217_code, serializer);
7585 <u64>::sse_encode(fractional_amount, serializer);
7586 }
7587 _ => {
7588 unimplemented!("");
7589 }
7590 }
7591 }
7592}
7593
7594impl SseEncode for crate::model::AssetBalance {
7595 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7597 <String>::sse_encode(self.asset_id, serializer);
7598 <u64>::sse_encode(self.balance_sat, serializer);
7599 <Option<String>>::sse_encode(self.name, serializer);
7600 <Option<String>>::sse_encode(self.ticker, serializer);
7601 <Option<f64>>::sse_encode(self.balance, serializer);
7602 }
7603}
7604
7605impl SseEncode for crate::model::AssetInfo {
7606 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7608 <String>::sse_encode(self.name, serializer);
7609 <String>::sse_encode(self.ticker, serializer);
7610 <f64>::sse_encode(self.amount, serializer);
7611 <Option<f64>>::sse_encode(self.fees, serializer);
7612 }
7613}
7614
7615impl SseEncode for crate::model::AssetMetadata {
7616 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7618 <String>::sse_encode(self.asset_id, serializer);
7619 <String>::sse_encode(self.name, serializer);
7620 <String>::sse_encode(self.ticker, serializer);
7621 <u8>::sse_encode(self.precision, serializer);
7622 <Option<String>>::sse_encode(self.fiat_id, serializer);
7623 }
7624}
7625
7626impl SseEncode for crate::model::BackupRequest {
7627 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7629 <Option<String>>::sse_encode(self.backup_path, serializer);
7630 }
7631}
7632
7633impl SseEncode for crate::bindings::BindingEventListener {
7634 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7636 <StreamSink<crate::model::SdkEvent,flutter_rust_bridge::for_generated::DcoCodec>>::sse_encode(self.stream, serializer);
7637 }
7638}
7639
7640impl SseEncode for crate::bindings::BitcoinAddressData {
7641 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7643 <String>::sse_encode(self.address, serializer);
7644 <crate::bindings::Network>::sse_encode(self.network, serializer);
7645 <Option<u64>>::sse_encode(self.amount_sat, serializer);
7646 <Option<String>>::sse_encode(self.label, serializer);
7647 <Option<String>>::sse_encode(self.message, serializer);
7648 }
7649}
7650
7651impl SseEncode for crate::model::BlockchainExplorer {
7652 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7654 match self {
7655 crate::model::BlockchainExplorer::Electrum { url } => {
7656 <i32>::sse_encode(0, serializer);
7657 <String>::sse_encode(url, serializer);
7658 }
7659 crate::model::BlockchainExplorer::Esplora {
7660 url,
7661 use_waterfalls,
7662 } => {
7663 <i32>::sse_encode(1, serializer);
7664 <String>::sse_encode(url, serializer);
7665 <bool>::sse_encode(use_waterfalls, serializer);
7666 }
7667 _ => {
7668 unimplemented!("");
7669 }
7670 }
7671 }
7672}
7673
7674impl SseEncode for crate::model::BlockchainInfo {
7675 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7677 <u32>::sse_encode(self.liquid_tip, serializer);
7678 <u32>::sse_encode(self.bitcoin_tip, serializer);
7679 }
7680}
7681
7682impl SseEncode for bool {
7683 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7685 serializer.cursor.write_u8(self as _).unwrap();
7686 }
7687}
7688
7689impl SseEncode for crate::model::BuyBitcoinProvider {
7690 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7692 <i32>::sse_encode(
7693 match self {
7694 crate::model::BuyBitcoinProvider::Moonpay => 0,
7695 _ => {
7696 unimplemented!("");
7697 }
7698 },
7699 serializer,
7700 );
7701 }
7702}
7703
7704impl SseEncode for crate::model::BuyBitcoinRequest {
7705 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7707 <crate::model::PrepareBuyBitcoinResponse>::sse_encode(self.prepare_response, serializer);
7708 <Option<String>>::sse_encode(self.redirect_url, serializer);
7709 }
7710}
7711
7712impl SseEncode for crate::model::CheckMessageRequest {
7713 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7715 <String>::sse_encode(self.message, serializer);
7716 <String>::sse_encode(self.pubkey, serializer);
7717 <String>::sse_encode(self.signature, serializer);
7718 }
7719}
7720
7721impl SseEncode for crate::model::CheckMessageResponse {
7722 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7724 <bool>::sse_encode(self.is_valid, serializer);
7725 }
7726}
7727
7728impl SseEncode for crate::model::Config {
7729 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7731 <crate::model::BlockchainExplorer>::sse_encode(self.liquid_explorer, serializer);
7732 <crate::model::BlockchainExplorer>::sse_encode(self.bitcoin_explorer, serializer);
7733 <String>::sse_encode(self.working_dir, serializer);
7734 <Option<String>>::sse_encode(self.cache_dir, serializer);
7735 <crate::model::LiquidNetwork>::sse_encode(self.network, serializer);
7736 <u64>::sse_encode(self.payment_timeout_sec, serializer);
7737 <Option<String>>::sse_encode(self.sync_service_url, serializer);
7738 <Option<u64>>::sse_encode(self.zero_conf_max_amount_sat, serializer);
7739 <Option<String>>::sse_encode(self.breez_api_key, serializer);
7740 <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_encode(
7741 self.external_input_parsers,
7742 serializer,
7743 );
7744 <bool>::sse_encode(self.use_default_external_input_parsers, serializer);
7745 <Option<u32>>::sse_encode(self.onchain_fee_rate_leeway_sat_per_vbyte, serializer);
7746 <Option<Vec<crate::model::AssetMetadata>>>::sse_encode(self.asset_metadata, serializer);
7747 <Option<String>>::sse_encode(self.sideswap_api_key, serializer);
7748 }
7749}
7750
7751impl SseEncode for crate::model::ConnectRequest {
7752 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7754 <crate::model::Config>::sse_encode(self.config, serializer);
7755 <Option<String>>::sse_encode(self.mnemonic, serializer);
7756 <Option<String>>::sse_encode(self.passphrase, serializer);
7757 <Option<Vec<u8>>>::sse_encode(self.seed, serializer);
7758 }
7759}
7760
7761impl SseEncode for crate::model::CreateBolt12InvoiceRequest {
7762 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7764 <String>::sse_encode(self.offer, serializer);
7765 <String>::sse_encode(self.invoice_request, serializer);
7766 }
7767}
7768
7769impl SseEncode for crate::model::CreateBolt12InvoiceResponse {
7770 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7772 <String>::sse_encode(self.invoice, serializer);
7773 }
7774}
7775
7776impl SseEncode for crate::bindings::CurrencyInfo {
7777 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7779 <String>::sse_encode(self.name, serializer);
7780 <u32>::sse_encode(self.fraction_size, serializer);
7781 <Option<u32>>::sse_encode(self.spacing, serializer);
7782 <Option<crate::bindings::Symbol>>::sse_encode(self.symbol, serializer);
7783 <Option<crate::bindings::Symbol>>::sse_encode(self.uniq_symbol, serializer);
7784 <Vec<crate::bindings::LocalizedName>>::sse_encode(self.localized_name, serializer);
7785 <Vec<crate::bindings::LocaleOverrides>>::sse_encode(self.locale_overrides, serializer);
7786 }
7787}
7788
7789impl SseEncode for crate::bindings::ExternalInputParser {
7790 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7792 <String>::sse_encode(self.provider_id, serializer);
7793 <String>::sse_encode(self.input_regex, serializer);
7794 <String>::sse_encode(self.parser_url, serializer);
7795 }
7796}
7797
7798impl SseEncode for f64 {
7799 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7801 serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
7802 }
7803}
7804
7805impl SseEncode for crate::model::FetchPaymentProposedFeesRequest {
7806 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7808 <String>::sse_encode(self.swap_id, serializer);
7809 }
7810}
7811
7812impl SseEncode for crate::model::FetchPaymentProposedFeesResponse {
7813 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7815 <String>::sse_encode(self.swap_id, serializer);
7816 <u64>::sse_encode(self.fees_sat, serializer);
7817 <u64>::sse_encode(self.payer_amount_sat, serializer);
7818 <u64>::sse_encode(self.receiver_amount_sat, serializer);
7819 }
7820}
7821
7822impl SseEncode for crate::bindings::FiatCurrency {
7823 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7825 <String>::sse_encode(self.id, serializer);
7826 <crate::bindings::CurrencyInfo>::sse_encode(self.info, serializer);
7827 }
7828}
7829
7830impl SseEncode for crate::model::GetInfoResponse {
7831 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7833 <crate::model::WalletInfo>::sse_encode(self.wallet_info, serializer);
7834 <crate::model::BlockchainInfo>::sse_encode(self.blockchain_info, serializer);
7835 }
7836}
7837
7838impl SseEncode for crate::model::GetPaymentRequest {
7839 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7841 match self {
7842 crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
7843 <i32>::sse_encode(0, serializer);
7844 <String>::sse_encode(payment_hash, serializer);
7845 }
7846 crate::model::GetPaymentRequest::SwapId { swap_id } => {
7847 <i32>::sse_encode(1, serializer);
7848 <String>::sse_encode(swap_id, serializer);
7849 }
7850 _ => {
7851 unimplemented!("");
7852 }
7853 }
7854 }
7855}
7856
7857impl SseEncode for i32 {
7858 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7860 serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
7861 }
7862}
7863
7864impl SseEncode for i64 {
7865 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7867 serializer.cursor.write_i64::<NativeEndian>(self).unwrap();
7868 }
7869}
7870
7871impl SseEncode for crate::bindings::InputType {
7872 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7874 match self {
7875 crate::bindings::InputType::BitcoinAddress { address } => {
7876 <i32>::sse_encode(0, serializer);
7877 <crate::bindings::BitcoinAddressData>::sse_encode(address, serializer);
7878 }
7879 crate::bindings::InputType::LiquidAddress { address } => {
7880 <i32>::sse_encode(1, serializer);
7881 <crate::bindings::LiquidAddressData>::sse_encode(address, serializer);
7882 }
7883 crate::bindings::InputType::Bolt11 { invoice } => {
7884 <i32>::sse_encode(2, serializer);
7885 <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
7886 }
7887 crate::bindings::InputType::Bolt12Offer {
7888 offer,
7889 bip353_address,
7890 } => {
7891 <i32>::sse_encode(3, serializer);
7892 <crate::bindings::LNOffer>::sse_encode(offer, serializer);
7893 <Option<String>>::sse_encode(bip353_address, serializer);
7894 }
7895 crate::bindings::InputType::NodeId { node_id } => {
7896 <i32>::sse_encode(4, serializer);
7897 <String>::sse_encode(node_id, serializer);
7898 }
7899 crate::bindings::InputType::Url { url } => {
7900 <i32>::sse_encode(5, serializer);
7901 <String>::sse_encode(url, serializer);
7902 }
7903 crate::bindings::InputType::LnUrlPay {
7904 data,
7905 bip353_address,
7906 } => {
7907 <i32>::sse_encode(6, serializer);
7908 <crate::bindings::LnUrlPayRequestData>::sse_encode(data, serializer);
7909 <Option<String>>::sse_encode(bip353_address, serializer);
7910 }
7911 crate::bindings::InputType::LnUrlWithdraw { data } => {
7912 <i32>::sse_encode(7, serializer);
7913 <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(data, serializer);
7914 }
7915 crate::bindings::InputType::LnUrlAuth { data } => {
7916 <i32>::sse_encode(8, serializer);
7917 <crate::bindings::LnUrlAuthRequestData>::sse_encode(data, serializer);
7918 }
7919 crate::bindings::InputType::LnUrlError { data } => {
7920 <i32>::sse_encode(9, serializer);
7921 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
7922 }
7923 _ => {
7924 unimplemented!("");
7925 }
7926 }
7927 }
7928}
7929
7930impl SseEncode for crate::model::LightningPaymentLimitsResponse {
7931 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7933 <crate::model::Limits>::sse_encode(self.send, serializer);
7934 <crate::model::Limits>::sse_encode(self.receive, serializer);
7935 }
7936}
7937
7938impl SseEncode for crate::model::Limits {
7939 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7941 <u64>::sse_encode(self.min_sat, serializer);
7942 <u64>::sse_encode(self.max_sat, serializer);
7943 <u64>::sse_encode(self.max_zero_conf_sat, serializer);
7944 }
7945}
7946
7947impl SseEncode for crate::bindings::LiquidAddressData {
7948 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7950 <String>::sse_encode(self.address, serializer);
7951 <crate::bindings::Network>::sse_encode(self.network, serializer);
7952 <Option<String>>::sse_encode(self.asset_id, serializer);
7953 <Option<f64>>::sse_encode(self.amount, serializer);
7954 <Option<u64>>::sse_encode(self.amount_sat, serializer);
7955 <Option<String>>::sse_encode(self.label, serializer);
7956 <Option<String>>::sse_encode(self.message, serializer);
7957 }
7958}
7959
7960impl SseEncode for crate::model::LiquidNetwork {
7961 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7963 <i32>::sse_encode(
7964 match self {
7965 crate::model::LiquidNetwork::Mainnet => 0,
7966 crate::model::LiquidNetwork::Testnet => 1,
7967 crate::model::LiquidNetwork::Regtest => 2,
7968 _ => {
7969 unimplemented!("");
7970 }
7971 },
7972 serializer,
7973 );
7974 }
7975}
7976
7977impl SseEncode for Vec<String> {
7978 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7980 <i32>::sse_encode(self.len() as _, serializer);
7981 for item in self {
7982 <String>::sse_encode(item, serializer);
7983 }
7984 }
7985}
7986
7987impl SseEncode for Vec<crate::model::AssetBalance> {
7988 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7990 <i32>::sse_encode(self.len() as _, serializer);
7991 for item in self {
7992 <crate::model::AssetBalance>::sse_encode(item, serializer);
7993 }
7994 }
7995}
7996
7997impl SseEncode for Vec<crate::model::AssetMetadata> {
7998 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8000 <i32>::sse_encode(self.len() as _, serializer);
8001 for item in self {
8002 <crate::model::AssetMetadata>::sse_encode(item, serializer);
8003 }
8004 }
8005}
8006
8007impl SseEncode for Vec<crate::bindings::ExternalInputParser> {
8008 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8010 <i32>::sse_encode(self.len() as _, serializer);
8011 for item in self {
8012 <crate::bindings::ExternalInputParser>::sse_encode(item, serializer);
8013 }
8014 }
8015}
8016
8017impl SseEncode for Vec<crate::bindings::FiatCurrency> {
8018 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8020 <i32>::sse_encode(self.len() as _, serializer);
8021 for item in self {
8022 <crate::bindings::FiatCurrency>::sse_encode(item, serializer);
8023 }
8024 }
8025}
8026
8027impl SseEncode for Vec<crate::bindings::LnOfferBlindedPath> {
8028 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8030 <i32>::sse_encode(self.len() as _, serializer);
8031 for item in self {
8032 <crate::bindings::LnOfferBlindedPath>::sse_encode(item, serializer);
8033 }
8034 }
8035}
8036
8037impl SseEncode for Vec<crate::bindings::LocaleOverrides> {
8038 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8040 <i32>::sse_encode(self.len() as _, serializer);
8041 for item in self {
8042 <crate::bindings::LocaleOverrides>::sse_encode(item, serializer);
8043 }
8044 }
8045}
8046
8047impl SseEncode for Vec<crate::bindings::LocalizedName> {
8048 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8050 <i32>::sse_encode(self.len() as _, serializer);
8051 for item in self {
8052 <crate::bindings::LocalizedName>::sse_encode(item, serializer);
8053 }
8054 }
8055}
8056
8057impl SseEncode for Vec<crate::model::Payment> {
8058 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8060 <i32>::sse_encode(self.len() as _, serializer);
8061 for item in self {
8062 <crate::model::Payment>::sse_encode(item, serializer);
8063 }
8064 }
8065}
8066
8067impl SseEncode for crate::model::ListPaymentDetails {
8068 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8070 match self {
8071 crate::model::ListPaymentDetails::Liquid {
8072 asset_id,
8073 destination,
8074 } => {
8075 <i32>::sse_encode(0, serializer);
8076 <Option<String>>::sse_encode(asset_id, serializer);
8077 <Option<String>>::sse_encode(destination, serializer);
8078 }
8079 crate::model::ListPaymentDetails::Bitcoin { address } => {
8080 <i32>::sse_encode(1, serializer);
8081 <Option<String>>::sse_encode(address, serializer);
8082 }
8083 _ => {
8084 unimplemented!("");
8085 }
8086 }
8087 }
8088}
8089
8090impl SseEncode for Vec<crate::model::PaymentState> {
8091 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8093 <i32>::sse_encode(self.len() as _, serializer);
8094 for item in self {
8095 <crate::model::PaymentState>::sse_encode(item, serializer);
8096 }
8097 }
8098}
8099
8100impl SseEncode for Vec<crate::model::PaymentType> {
8101 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8103 <i32>::sse_encode(self.len() as _, serializer);
8104 for item in self {
8105 <crate::model::PaymentType>::sse_encode(item, serializer);
8106 }
8107 }
8108}
8109
8110impl SseEncode for crate::model::ListPaymentsRequest {
8111 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8113 <Option<Vec<crate::model::PaymentType>>>::sse_encode(self.filters, serializer);
8114 <Option<Vec<crate::model::PaymentState>>>::sse_encode(self.states, serializer);
8115 <Option<i64>>::sse_encode(self.from_timestamp, serializer);
8116 <Option<i64>>::sse_encode(self.to_timestamp, serializer);
8117 <Option<u32>>::sse_encode(self.offset, serializer);
8118 <Option<u32>>::sse_encode(self.limit, serializer);
8119 <Option<crate::model::ListPaymentDetails>>::sse_encode(self.details, serializer);
8120 <Option<bool>>::sse_encode(self.sort_ascending, serializer);
8121 }
8122}
8123
8124impl SseEncode for Vec<u8> {
8125 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8127 <i32>::sse_encode(self.len() as _, serializer);
8128 for item in self {
8129 <u8>::sse_encode(item, serializer);
8130 }
8131 }
8132}
8133
8134impl SseEncode for Vec<crate::bindings::Rate> {
8135 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8137 <i32>::sse_encode(self.len() as _, serializer);
8138 for item in self {
8139 <crate::bindings::Rate>::sse_encode(item, serializer);
8140 }
8141 }
8142}
8143
8144impl SseEncode for Vec<crate::model::RefundableSwap> {
8145 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8147 <i32>::sse_encode(self.len() as _, serializer);
8148 for item in self {
8149 <crate::model::RefundableSwap>::sse_encode(item, serializer);
8150 }
8151 }
8152}
8153
8154impl SseEncode for Vec<crate::bindings::RouteHint> {
8155 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8157 <i32>::sse_encode(self.len() as _, serializer);
8158 for item in self {
8159 <crate::bindings::RouteHint>::sse_encode(item, serializer);
8160 }
8161 }
8162}
8163
8164impl SseEncode for Vec<crate::bindings::RouteHintHop> {
8165 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8167 <i32>::sse_encode(self.len() as _, serializer);
8168 for item in self {
8169 <crate::bindings::RouteHintHop>::sse_encode(item, serializer);
8170 }
8171 }
8172}
8173
8174impl SseEncode for crate::bindings::LNInvoice {
8175 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8177 <String>::sse_encode(self.bolt11, serializer);
8178 <crate::bindings::Network>::sse_encode(self.network, serializer);
8179 <String>::sse_encode(self.payee_pubkey, serializer);
8180 <String>::sse_encode(self.payment_hash, serializer);
8181 <Option<String>>::sse_encode(self.description, serializer);
8182 <Option<String>>::sse_encode(self.description_hash, serializer);
8183 <Option<u64>>::sse_encode(self.amount_msat, serializer);
8184 <u64>::sse_encode(self.timestamp, serializer);
8185 <u64>::sse_encode(self.expiry, serializer);
8186 <Vec<crate::bindings::RouteHint>>::sse_encode(self.routing_hints, serializer);
8187 <Vec<u8>>::sse_encode(self.payment_secret, serializer);
8188 <u64>::sse_encode(self.min_final_cltv_expiry_delta, serializer);
8189 }
8190}
8191
8192impl SseEncode for crate::bindings::LNOffer {
8193 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8195 <String>::sse_encode(self.offer, serializer);
8196 <Vec<String>>::sse_encode(self.chains, serializer);
8197 <Option<crate::bindings::Amount>>::sse_encode(self.min_amount, serializer);
8198 <Option<String>>::sse_encode(self.description, serializer);
8199 <Option<u64>>::sse_encode(self.absolute_expiry, serializer);
8200 <Option<String>>::sse_encode(self.issuer, serializer);
8201 <Option<String>>::sse_encode(self.signing_pubkey, serializer);
8202 <Vec<crate::bindings::LnOfferBlindedPath>>::sse_encode(self.paths, serializer);
8203 }
8204}
8205
8206impl SseEncode for crate::bindings::LnOfferBlindedPath {
8207 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8209 <Vec<String>>::sse_encode(self.blinded_hops, serializer);
8210 }
8211}
8212
8213impl SseEncode for crate::bindings::duplicates::LnUrlAuthError {
8214 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8216 match self {
8217 crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
8218 <i32>::sse_encode(0, serializer);
8219 <String>::sse_encode(err, serializer);
8220 }
8221 crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
8222 <i32>::sse_encode(1, serializer);
8223 <String>::sse_encode(err, serializer);
8224 }
8225 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
8226 <i32>::sse_encode(2, serializer);
8227 <String>::sse_encode(err, serializer);
8228 }
8229 _ => {
8230 unimplemented!("");
8231 }
8232 }
8233 }
8234}
8235
8236impl SseEncode for crate::bindings::LnUrlAuthRequestData {
8237 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8239 <String>::sse_encode(self.k1, serializer);
8240 <Option<String>>::sse_encode(self.action, serializer);
8241 <String>::sse_encode(self.domain, serializer);
8242 <String>::sse_encode(self.url, serializer);
8243 }
8244}
8245
8246impl SseEncode for crate::bindings::duplicates::LnUrlCallbackStatus {
8247 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8249 match self {
8250 crate::bindings::duplicates::LnUrlCallbackStatus::Ok => {
8251 <i32>::sse_encode(0, serializer);
8252 }
8253 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
8254 <i32>::sse_encode(1, serializer);
8255 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8256 }
8257 _ => {
8258 unimplemented!("");
8259 }
8260 }
8261 }
8262}
8263
8264impl SseEncode for crate::bindings::LnUrlErrorData {
8265 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8267 <String>::sse_encode(self.reason, serializer);
8268 }
8269}
8270
8271impl SseEncode for crate::model::LnUrlInfo {
8272 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8274 <Option<String>>::sse_encode(self.ln_address, serializer);
8275 <Option<String>>::sse_encode(self.lnurl_pay_comment, serializer);
8276 <Option<String>>::sse_encode(self.lnurl_pay_domain, serializer);
8277 <Option<String>>::sse_encode(self.lnurl_pay_metadata, serializer);
8278 <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8279 self.lnurl_pay_success_action,
8280 serializer,
8281 );
8282 <Option<crate::bindings::SuccessAction>>::sse_encode(
8283 self.lnurl_pay_unprocessed_success_action,
8284 serializer,
8285 );
8286 <Option<String>>::sse_encode(self.lnurl_withdraw_endpoint, serializer);
8287 }
8288}
8289
8290impl SseEncode for crate::bindings::duplicates::LnUrlPayError {
8291 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8293 match self {
8294 crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => {
8295 <i32>::sse_encode(0, serializer);
8296 }
8297 crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
8298 <i32>::sse_encode(1, serializer);
8299 <String>::sse_encode(err, serializer);
8300 }
8301 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
8302 <i32>::sse_encode(2, serializer);
8303 <String>::sse_encode(err, serializer);
8304 }
8305 crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
8306 <i32>::sse_encode(3, serializer);
8307 <String>::sse_encode(err, serializer);
8308 }
8309 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
8310 <i32>::sse_encode(4, serializer);
8311 <String>::sse_encode(err, serializer);
8312 }
8313 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
8314 <i32>::sse_encode(5, serializer);
8315 <String>::sse_encode(err, serializer);
8316 }
8317 crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
8318 <i32>::sse_encode(6, serializer);
8319 <String>::sse_encode(err, serializer);
8320 }
8321 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
8322 <i32>::sse_encode(7, serializer);
8323 <String>::sse_encode(err, serializer);
8324 }
8325 crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
8326 <i32>::sse_encode(8, serializer);
8327 <String>::sse_encode(err, serializer);
8328 }
8329 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
8330 <i32>::sse_encode(9, serializer);
8331 <String>::sse_encode(err, serializer);
8332 }
8333 crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
8334 <i32>::sse_encode(10, serializer);
8335 <String>::sse_encode(err, serializer);
8336 }
8337 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
8338 <i32>::sse_encode(11, serializer);
8339 <String>::sse_encode(err, serializer);
8340 }
8341 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
8342 <i32>::sse_encode(12, serializer);
8343 <String>::sse_encode(err, serializer);
8344 }
8345 _ => {
8346 unimplemented!("");
8347 }
8348 }
8349 }
8350}
8351
8352impl SseEncode for crate::bindings::LnUrlPayErrorData {
8353 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8355 <String>::sse_encode(self.payment_hash, serializer);
8356 <String>::sse_encode(self.reason, serializer);
8357 }
8358}
8359
8360impl SseEncode for crate::model::LnUrlPayRequest {
8361 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8363 <crate::model::PrepareLnUrlPayResponse>::sse_encode(self.prepare_response, serializer);
8364 }
8365}
8366
8367impl SseEncode for crate::bindings::LnUrlPayRequestData {
8368 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8370 <String>::sse_encode(self.callback, serializer);
8371 <u64>::sse_encode(self.min_sendable, serializer);
8372 <u64>::sse_encode(self.max_sendable, serializer);
8373 <String>::sse_encode(self.metadata_str, serializer);
8374 <u16>::sse_encode(self.comment_allowed, serializer);
8375 <String>::sse_encode(self.domain, serializer);
8376 <bool>::sse_encode(self.allows_nostr, serializer);
8377 <Option<String>>::sse_encode(self.nostr_pubkey, serializer);
8378 <Option<String>>::sse_encode(self.ln_address, serializer);
8379 }
8380}
8381
8382impl SseEncode for crate::model::LnUrlPayResult {
8383 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8385 match self {
8386 crate::model::LnUrlPayResult::EndpointSuccess { data } => {
8387 <i32>::sse_encode(0, serializer);
8388 <crate::model::LnUrlPaySuccessData>::sse_encode(data, serializer);
8389 }
8390 crate::model::LnUrlPayResult::EndpointError { data } => {
8391 <i32>::sse_encode(1, serializer);
8392 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8393 }
8394 crate::model::LnUrlPayResult::PayError { data } => {
8395 <i32>::sse_encode(2, serializer);
8396 <crate::bindings::LnUrlPayErrorData>::sse_encode(data, serializer);
8397 }
8398 _ => {
8399 unimplemented!("");
8400 }
8401 }
8402 }
8403}
8404
8405impl SseEncode for crate::model::LnUrlPaySuccessData {
8406 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8408 <crate::model::Payment>::sse_encode(self.payment, serializer);
8409 <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8410 self.success_action,
8411 serializer,
8412 );
8413 }
8414}
8415
8416impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawError {
8417 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8419 match self {
8420 crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
8421 <i32>::sse_encode(0, serializer);
8422 <String>::sse_encode(err, serializer);
8423 }
8424 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
8425 <i32>::sse_encode(1, serializer);
8426 <String>::sse_encode(err, serializer);
8427 }
8428 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
8429 <i32>::sse_encode(2, serializer);
8430 <String>::sse_encode(err, serializer);
8431 }
8432 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
8433 <i32>::sse_encode(3, serializer);
8434 <String>::sse_encode(err, serializer);
8435 }
8436 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
8437 <i32>::sse_encode(4, serializer);
8438 <String>::sse_encode(err, serializer);
8439 }
8440 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
8441 <i32>::sse_encode(5, serializer);
8442 <String>::sse_encode(err, serializer);
8443 }
8444 _ => {
8445 unimplemented!("");
8446 }
8447 }
8448 }
8449}
8450
8451impl SseEncode for crate::bindings::LnUrlWithdrawRequest {
8452 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8454 <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(self.data, serializer);
8455 <u64>::sse_encode(self.amount_msat, serializer);
8456 <Option<String>>::sse_encode(self.description, serializer);
8457 }
8458}
8459
8460impl SseEncode for crate::bindings::LnUrlWithdrawRequestData {
8461 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8463 <String>::sse_encode(self.callback, serializer);
8464 <String>::sse_encode(self.k1, serializer);
8465 <String>::sse_encode(self.default_description, serializer);
8466 <u64>::sse_encode(self.min_withdrawable, serializer);
8467 <u64>::sse_encode(self.max_withdrawable, serializer);
8468 }
8469}
8470
8471impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawResult {
8472 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8474 match self {
8475 crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
8476 <i32>::sse_encode(0, serializer);
8477 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8478 data, serializer,
8479 );
8480 }
8481 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
8482 <i32>::sse_encode(1, serializer);
8483 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8484 data, serializer,
8485 );
8486 }
8487 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
8488 <i32>::sse_encode(2, serializer);
8489 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8490 }
8491 _ => {
8492 unimplemented!("");
8493 }
8494 }
8495 }
8496}
8497
8498impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
8499 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8501 <crate::bindings::LNInvoice>::sse_encode(self.invoice, serializer);
8502 }
8503}
8504
8505impl SseEncode for crate::bindings::LocaleOverrides {
8506 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8508 <String>::sse_encode(self.locale, serializer);
8509 <Option<u32>>::sse_encode(self.spacing, serializer);
8510 <crate::bindings::Symbol>::sse_encode(self.symbol, serializer);
8511 }
8512}
8513
8514impl SseEncode for crate::bindings::LocalizedName {
8515 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8517 <String>::sse_encode(self.locale, serializer);
8518 <String>::sse_encode(self.name, serializer);
8519 }
8520}
8521
8522impl SseEncode for crate::model::LogEntry {
8523 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8525 <String>::sse_encode(self.line, serializer);
8526 <String>::sse_encode(self.level, serializer);
8527 }
8528}
8529
8530impl SseEncode for crate::bindings::MessageSuccessActionData {
8531 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8533 <String>::sse_encode(self.message, serializer);
8534 }
8535}
8536
8537impl SseEncode for crate::bindings::Network {
8538 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8540 <i32>::sse_encode(
8541 match self {
8542 crate::bindings::Network::Bitcoin => 0,
8543 crate::bindings::Network::Testnet => 1,
8544 crate::bindings::Network::Signet => 2,
8545 crate::bindings::Network::Regtest => 3,
8546 _ => {
8547 unimplemented!("");
8548 }
8549 },
8550 serializer,
8551 );
8552 }
8553}
8554
8555impl SseEncode for crate::model::OnchainPaymentLimitsResponse {
8556 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8558 <crate::model::Limits>::sse_encode(self.send, serializer);
8559 <crate::model::Limits>::sse_encode(self.receive, serializer);
8560 }
8561}
8562
8563impl SseEncode for Option<String> {
8564 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8566 <bool>::sse_encode(self.is_some(), serializer);
8567 if let Some(value) = self {
8568 <String>::sse_encode(value, serializer);
8569 }
8570 }
8571}
8572
8573impl SseEncode for Option<crate::bindings::Amount> {
8574 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8576 <bool>::sse_encode(self.is_some(), serializer);
8577 if let Some(value) = self {
8578 <crate::bindings::Amount>::sse_encode(value, serializer);
8579 }
8580 }
8581}
8582
8583impl SseEncode for Option<crate::model::AssetInfo> {
8584 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8586 <bool>::sse_encode(self.is_some(), serializer);
8587 if let Some(value) = self {
8588 <crate::model::AssetInfo>::sse_encode(value, serializer);
8589 }
8590 }
8591}
8592
8593impl SseEncode for Option<bool> {
8594 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8596 <bool>::sse_encode(self.is_some(), serializer);
8597 if let Some(value) = self {
8598 <bool>::sse_encode(value, serializer);
8599 }
8600 }
8601}
8602
8603impl SseEncode for Option<f64> {
8604 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8606 <bool>::sse_encode(self.is_some(), serializer);
8607 if let Some(value) = self {
8608 <f64>::sse_encode(value, serializer);
8609 }
8610 }
8611}
8612
8613impl SseEncode for Option<i64> {
8614 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8616 <bool>::sse_encode(self.is_some(), serializer);
8617 if let Some(value) = self {
8618 <i64>::sse_encode(value, serializer);
8619 }
8620 }
8621}
8622
8623impl SseEncode for Option<crate::model::ListPaymentDetails> {
8624 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8626 <bool>::sse_encode(self.is_some(), serializer);
8627 if let Some(value) = self {
8628 <crate::model::ListPaymentDetails>::sse_encode(value, serializer);
8629 }
8630 }
8631}
8632
8633impl SseEncode for Option<crate::model::LnUrlInfo> {
8634 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8636 <bool>::sse_encode(self.is_some(), serializer);
8637 if let Some(value) = self {
8638 <crate::model::LnUrlInfo>::sse_encode(value, serializer);
8639 }
8640 }
8641}
8642
8643impl SseEncode for Option<crate::model::PayAmount> {
8644 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8646 <bool>::sse_encode(self.is_some(), serializer);
8647 if let Some(value) = self {
8648 <crate::model::PayAmount>::sse_encode(value, serializer);
8649 }
8650 }
8651}
8652
8653impl SseEncode for Option<crate::model::Payment> {
8654 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8656 <bool>::sse_encode(self.is_some(), serializer);
8657 if let Some(value) = self {
8658 <crate::model::Payment>::sse_encode(value, serializer);
8659 }
8660 }
8661}
8662
8663impl SseEncode for Option<crate::model::ReceiveAmount> {
8664 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8666 <bool>::sse_encode(self.is_some(), serializer);
8667 if let Some(value) = self {
8668 <crate::model::ReceiveAmount>::sse_encode(value, serializer);
8669 }
8670 }
8671}
8672
8673impl SseEncode for Option<crate::bindings::SuccessAction> {
8674 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8676 <bool>::sse_encode(self.is_some(), serializer);
8677 if let Some(value) = self {
8678 <crate::bindings::SuccessAction>::sse_encode(value, serializer);
8679 }
8680 }
8681}
8682
8683impl SseEncode for Option<crate::bindings::SuccessActionProcessed> {
8684 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8686 <bool>::sse_encode(self.is_some(), serializer);
8687 if let Some(value) = self {
8688 <crate::bindings::SuccessActionProcessed>::sse_encode(value, serializer);
8689 }
8690 }
8691}
8692
8693impl SseEncode for Option<crate::bindings::Symbol> {
8694 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8696 <bool>::sse_encode(self.is_some(), serializer);
8697 if let Some(value) = self {
8698 <crate::bindings::Symbol>::sse_encode(value, serializer);
8699 }
8700 }
8701}
8702
8703impl SseEncode for Option<u32> {
8704 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8706 <bool>::sse_encode(self.is_some(), serializer);
8707 if let Some(value) = self {
8708 <u32>::sse_encode(value, serializer);
8709 }
8710 }
8711}
8712
8713impl SseEncode for Option<u64> {
8714 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8716 <bool>::sse_encode(self.is_some(), serializer);
8717 if let Some(value) = self {
8718 <u64>::sse_encode(value, serializer);
8719 }
8720 }
8721}
8722
8723impl SseEncode for Option<Vec<crate::model::AssetMetadata>> {
8724 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8726 <bool>::sse_encode(self.is_some(), serializer);
8727 if let Some(value) = self {
8728 <Vec<crate::model::AssetMetadata>>::sse_encode(value, serializer);
8729 }
8730 }
8731}
8732
8733impl SseEncode for Option<Vec<crate::bindings::ExternalInputParser>> {
8734 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8736 <bool>::sse_encode(self.is_some(), serializer);
8737 if let Some(value) = self {
8738 <Vec<crate::bindings::ExternalInputParser>>::sse_encode(value, serializer);
8739 }
8740 }
8741}
8742
8743impl SseEncode for Option<Vec<crate::model::PaymentState>> {
8744 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8746 <bool>::sse_encode(self.is_some(), serializer);
8747 if let Some(value) = self {
8748 <Vec<crate::model::PaymentState>>::sse_encode(value, serializer);
8749 }
8750 }
8751}
8752
8753impl SseEncode for Option<Vec<crate::model::PaymentType>> {
8754 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8756 <bool>::sse_encode(self.is_some(), serializer);
8757 if let Some(value) = self {
8758 <Vec<crate::model::PaymentType>>::sse_encode(value, serializer);
8759 }
8760 }
8761}
8762
8763impl SseEncode for Option<Vec<u8>> {
8764 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8766 <bool>::sse_encode(self.is_some(), serializer);
8767 if let Some(value) = self {
8768 <Vec<u8>>::sse_encode(value, serializer);
8769 }
8770 }
8771}
8772
8773impl SseEncode for crate::model::PayAmount {
8774 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8776 match self {
8777 crate::model::PayAmount::Bitcoin {
8778 receiver_amount_sat,
8779 } => {
8780 <i32>::sse_encode(0, serializer);
8781 <u64>::sse_encode(receiver_amount_sat, serializer);
8782 }
8783 crate::model::PayAmount::Asset {
8784 asset_id,
8785 receiver_amount,
8786 estimate_asset_fees,
8787 } => {
8788 <i32>::sse_encode(1, serializer);
8789 <String>::sse_encode(asset_id, serializer);
8790 <f64>::sse_encode(receiver_amount, serializer);
8791 <Option<bool>>::sse_encode(estimate_asset_fees, serializer);
8792 }
8793 crate::model::PayAmount::Drain => {
8794 <i32>::sse_encode(2, serializer);
8795 }
8796 _ => {
8797 unimplemented!("");
8798 }
8799 }
8800 }
8801}
8802
8803impl SseEncode for crate::model::PayOnchainRequest {
8804 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8806 <String>::sse_encode(self.address, serializer);
8807 <crate::model::PreparePayOnchainResponse>::sse_encode(self.prepare_response, serializer);
8808 }
8809}
8810
8811impl SseEncode for crate::model::Payment {
8812 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8814 <Option<String>>::sse_encode(self.destination, serializer);
8815 <Option<String>>::sse_encode(self.tx_id, serializer);
8816 <Option<String>>::sse_encode(self.unblinding_data, serializer);
8817 <u32>::sse_encode(self.timestamp, serializer);
8818 <u64>::sse_encode(self.amount_sat, serializer);
8819 <u64>::sse_encode(self.fees_sat, serializer);
8820 <Option<u64>>::sse_encode(self.swapper_fees_sat, serializer);
8821 <crate::model::PaymentType>::sse_encode(self.payment_type, serializer);
8822 <crate::model::PaymentState>::sse_encode(self.status, serializer);
8823 <crate::model::PaymentDetails>::sse_encode(self.details, serializer);
8824 }
8825}
8826
8827impl SseEncode for crate::model::PaymentDetails {
8828 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8830 match self {
8831 crate::model::PaymentDetails::Lightning {
8832 swap_id,
8833 description,
8834 liquid_expiration_blockheight,
8835 preimage,
8836 invoice,
8837 bolt12_offer,
8838 payment_hash,
8839 destination_pubkey,
8840 lnurl_info,
8841 bip353_address,
8842 claim_tx_id,
8843 refund_tx_id,
8844 refund_tx_amount_sat,
8845 } => {
8846 <i32>::sse_encode(0, serializer);
8847 <String>::sse_encode(swap_id, serializer);
8848 <String>::sse_encode(description, serializer);
8849 <u32>::sse_encode(liquid_expiration_blockheight, serializer);
8850 <Option<String>>::sse_encode(preimage, serializer);
8851 <Option<String>>::sse_encode(invoice, serializer);
8852 <Option<String>>::sse_encode(bolt12_offer, serializer);
8853 <Option<String>>::sse_encode(payment_hash, serializer);
8854 <Option<String>>::sse_encode(destination_pubkey, serializer);
8855 <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8856 <Option<String>>::sse_encode(bip353_address, serializer);
8857 <Option<String>>::sse_encode(claim_tx_id, serializer);
8858 <Option<String>>::sse_encode(refund_tx_id, serializer);
8859 <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8860 }
8861 crate::model::PaymentDetails::Liquid {
8862 destination,
8863 description,
8864 asset_id,
8865 asset_info,
8866 lnurl_info,
8867 bip353_address,
8868 } => {
8869 <i32>::sse_encode(1, serializer);
8870 <String>::sse_encode(destination, serializer);
8871 <String>::sse_encode(description, serializer);
8872 <String>::sse_encode(asset_id, serializer);
8873 <Option<crate::model::AssetInfo>>::sse_encode(asset_info, serializer);
8874 <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8875 <Option<String>>::sse_encode(bip353_address, serializer);
8876 }
8877 crate::model::PaymentDetails::Bitcoin {
8878 swap_id,
8879 description,
8880 auto_accepted_fees,
8881 liquid_expiration_blockheight,
8882 bitcoin_expiration_blockheight,
8883 claim_tx_id,
8884 refund_tx_id,
8885 refund_tx_amount_sat,
8886 } => {
8887 <i32>::sse_encode(2, serializer);
8888 <String>::sse_encode(swap_id, serializer);
8889 <String>::sse_encode(description, serializer);
8890 <bool>::sse_encode(auto_accepted_fees, serializer);
8891 <Option<u32>>::sse_encode(liquid_expiration_blockheight, serializer);
8892 <Option<u32>>::sse_encode(bitcoin_expiration_blockheight, serializer);
8893 <Option<String>>::sse_encode(claim_tx_id, serializer);
8894 <Option<String>>::sse_encode(refund_tx_id, serializer);
8895 <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8896 }
8897 _ => {
8898 unimplemented!("");
8899 }
8900 }
8901 }
8902}
8903
8904impl SseEncode for crate::error::PaymentError {
8905 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8907 match self {
8908 crate::error::PaymentError::AlreadyClaimed => {
8909 <i32>::sse_encode(0, serializer);
8910 }
8911 crate::error::PaymentError::AlreadyPaid => {
8912 <i32>::sse_encode(1, serializer);
8913 }
8914 crate::error::PaymentError::PaymentInProgress => {
8915 <i32>::sse_encode(2, serializer);
8916 }
8917 crate::error::PaymentError::AmountOutOfRange { min, max } => {
8918 <i32>::sse_encode(3, serializer);
8919 <u64>::sse_encode(min, serializer);
8920 <u64>::sse_encode(max, serializer);
8921 }
8922 crate::error::PaymentError::AmountMissing { err } => {
8923 <i32>::sse_encode(4, serializer);
8924 <String>::sse_encode(err, serializer);
8925 }
8926 crate::error::PaymentError::AssetError { err } => {
8927 <i32>::sse_encode(5, serializer);
8928 <String>::sse_encode(err, serializer);
8929 }
8930 crate::error::PaymentError::InvalidNetwork { err } => {
8931 <i32>::sse_encode(6, serializer);
8932 <String>::sse_encode(err, serializer);
8933 }
8934 crate::error::PaymentError::Generic { err } => {
8935 <i32>::sse_encode(7, serializer);
8936 <String>::sse_encode(err, serializer);
8937 }
8938 crate::error::PaymentError::InvalidOrExpiredFees => {
8939 <i32>::sse_encode(8, serializer);
8940 }
8941 crate::error::PaymentError::InsufficientFunds => {
8942 <i32>::sse_encode(9, serializer);
8943 }
8944 crate::error::PaymentError::InvalidDescription { err } => {
8945 <i32>::sse_encode(10, serializer);
8946 <String>::sse_encode(err, serializer);
8947 }
8948 crate::error::PaymentError::InvalidInvoice { err } => {
8949 <i32>::sse_encode(11, serializer);
8950 <String>::sse_encode(err, serializer);
8951 }
8952 crate::error::PaymentError::InvalidPreimage => {
8953 <i32>::sse_encode(12, serializer);
8954 }
8955 crate::error::PaymentError::PairsNotFound => {
8956 <i32>::sse_encode(13, serializer);
8957 }
8958 crate::error::PaymentError::PaymentTimeout => {
8959 <i32>::sse_encode(14, serializer);
8960 }
8961 crate::error::PaymentError::PersistError => {
8962 <i32>::sse_encode(15, serializer);
8963 }
8964 crate::error::PaymentError::ReceiveError { err } => {
8965 <i32>::sse_encode(16, serializer);
8966 <String>::sse_encode(err, serializer);
8967 }
8968 crate::error::PaymentError::Refunded { err, refund_tx_id } => {
8969 <i32>::sse_encode(17, serializer);
8970 <String>::sse_encode(err, serializer);
8971 <String>::sse_encode(refund_tx_id, serializer);
8972 }
8973 crate::error::PaymentError::SelfTransferNotSupported => {
8974 <i32>::sse_encode(18, serializer);
8975 }
8976 crate::error::PaymentError::SendError { err } => {
8977 <i32>::sse_encode(19, serializer);
8978 <String>::sse_encode(err, serializer);
8979 }
8980 crate::error::PaymentError::SignerError { err } => {
8981 <i32>::sse_encode(20, serializer);
8982 <String>::sse_encode(err, serializer);
8983 }
8984 _ => {
8985 unimplemented!("");
8986 }
8987 }
8988 }
8989}
8990
8991impl SseEncode for crate::model::PaymentMethod {
8992 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8994 <i32>::sse_encode(
8995 match self {
8996 crate::model::PaymentMethod::Lightning => 0,
8997 crate::model::PaymentMethod::Bolt11Invoice => 1,
8998 crate::model::PaymentMethod::Bolt12Offer => 2,
8999 crate::model::PaymentMethod::BitcoinAddress => 3,
9000 crate::model::PaymentMethod::LiquidAddress => 4,
9001 _ => {
9002 unimplemented!("");
9003 }
9004 },
9005 serializer,
9006 );
9007 }
9008}
9009
9010impl SseEncode for crate::model::PaymentState {
9011 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9013 <i32>::sse_encode(
9014 match self {
9015 crate::model::PaymentState::Created => 0,
9016 crate::model::PaymentState::Pending => 1,
9017 crate::model::PaymentState::Complete => 2,
9018 crate::model::PaymentState::Failed => 3,
9019 crate::model::PaymentState::TimedOut => 4,
9020 crate::model::PaymentState::Refundable => 5,
9021 crate::model::PaymentState::RefundPending => 6,
9022 crate::model::PaymentState::WaitingFeeAcceptance => 7,
9023 _ => {
9024 unimplemented!("");
9025 }
9026 },
9027 serializer,
9028 );
9029 }
9030}
9031
9032impl SseEncode for crate::model::PaymentType {
9033 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9035 <i32>::sse_encode(
9036 match self {
9037 crate::model::PaymentType::Receive => 0,
9038 crate::model::PaymentType::Send => 1,
9039 _ => {
9040 unimplemented!("");
9041 }
9042 },
9043 serializer,
9044 );
9045 }
9046}
9047
9048impl SseEncode for crate::model::PrepareBuyBitcoinRequest {
9049 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9051 <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9052 <u64>::sse_encode(self.amount_sat, serializer);
9053 }
9054}
9055
9056impl SseEncode for crate::model::PrepareBuyBitcoinResponse {
9057 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9059 <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9060 <u64>::sse_encode(self.amount_sat, serializer);
9061 <u64>::sse_encode(self.fees_sat, serializer);
9062 }
9063}
9064
9065impl SseEncode for crate::model::PrepareLnUrlPayRequest {
9066 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9068 <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9069 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9070 <Option<String>>::sse_encode(self.bip353_address, serializer);
9071 <Option<String>>::sse_encode(self.comment, serializer);
9072 <Option<bool>>::sse_encode(self.validate_success_action_url, serializer);
9073 }
9074}
9075
9076impl SseEncode for crate::model::PrepareLnUrlPayResponse {
9077 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9079 <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9080 <u64>::sse_encode(self.fees_sat, serializer);
9081 <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9082 <Option<String>>::sse_encode(self.comment, serializer);
9083 <Option<crate::bindings::SuccessAction>>::sse_encode(self.success_action, serializer);
9084 }
9085}
9086
9087impl SseEncode for crate::model::PreparePayOnchainRequest {
9088 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9090 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9091 <Option<u32>>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9092 }
9093}
9094
9095impl SseEncode for crate::model::PreparePayOnchainResponse {
9096 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9098 <u64>::sse_encode(self.receiver_amount_sat, serializer);
9099 <u64>::sse_encode(self.claim_fees_sat, serializer);
9100 <u64>::sse_encode(self.total_fees_sat, serializer);
9101 }
9102}
9103
9104impl SseEncode for crate::model::PrepareReceiveRequest {
9105 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9107 <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9108 <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9109 }
9110}
9111
9112impl SseEncode for crate::model::PrepareReceiveResponse {
9113 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9115 <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9116 <u64>::sse_encode(self.fees_sat, serializer);
9117 <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9118 <Option<u64>>::sse_encode(self.min_payer_amount_sat, serializer);
9119 <Option<u64>>::sse_encode(self.max_payer_amount_sat, serializer);
9120 <Option<f64>>::sse_encode(self.swapper_feerate, serializer);
9121 }
9122}
9123
9124impl SseEncode for crate::model::PrepareRefundRequest {
9125 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9127 <String>::sse_encode(self.swap_address, serializer);
9128 <String>::sse_encode(self.refund_address, serializer);
9129 <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9130 }
9131}
9132
9133impl SseEncode for crate::model::PrepareRefundResponse {
9134 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9136 <u32>::sse_encode(self.tx_vsize, serializer);
9137 <u64>::sse_encode(self.tx_fee_sat, serializer);
9138 <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9139 }
9140}
9141
9142impl SseEncode for crate::model::PrepareSendRequest {
9143 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9145 <String>::sse_encode(self.destination, serializer);
9146 <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9147 }
9148}
9149
9150impl SseEncode for crate::model::PrepareSendResponse {
9151 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9153 <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9154 <Option<u64>>::sse_encode(self.fees_sat, serializer);
9155 <Option<f64>>::sse_encode(self.estimated_asset_fees, serializer);
9156 }
9157}
9158
9159impl SseEncode for crate::bindings::Rate {
9160 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9162 <String>::sse_encode(self.coin, serializer);
9163 <f64>::sse_encode(self.value, serializer);
9164 }
9165}
9166
9167impl SseEncode for crate::model::ReceiveAmount {
9168 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9170 match self {
9171 crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
9172 <i32>::sse_encode(0, serializer);
9173 <u64>::sse_encode(payer_amount_sat, serializer);
9174 }
9175 crate::model::ReceiveAmount::Asset {
9176 asset_id,
9177 payer_amount,
9178 } => {
9179 <i32>::sse_encode(1, serializer);
9180 <String>::sse_encode(asset_id, serializer);
9181 <Option<f64>>::sse_encode(payer_amount, serializer);
9182 }
9183 _ => {
9184 unimplemented!("");
9185 }
9186 }
9187 }
9188}
9189
9190impl SseEncode for crate::model::ReceivePaymentRequest {
9191 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9193 <crate::model::PrepareReceiveResponse>::sse_encode(self.prepare_response, serializer);
9194 <Option<String>>::sse_encode(self.description, serializer);
9195 <Option<bool>>::sse_encode(self.use_description_hash, serializer);
9196 }
9197}
9198
9199impl SseEncode for crate::model::ReceivePaymentResponse {
9200 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9202 <String>::sse_encode(self.destination, serializer);
9203 }
9204}
9205
9206impl SseEncode for crate::model::RecommendedFees {
9207 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9209 <u64>::sse_encode(self.fastest_fee, serializer);
9210 <u64>::sse_encode(self.half_hour_fee, serializer);
9211 <u64>::sse_encode(self.hour_fee, serializer);
9212 <u64>::sse_encode(self.economy_fee, serializer);
9213 <u64>::sse_encode(self.minimum_fee, serializer);
9214 }
9215}
9216
9217impl SseEncode for crate::model::RefundRequest {
9218 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9220 <String>::sse_encode(self.swap_address, serializer);
9221 <String>::sse_encode(self.refund_address, serializer);
9222 <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9223 }
9224}
9225
9226impl SseEncode for crate::model::RefundResponse {
9227 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9229 <String>::sse_encode(self.refund_tx_id, serializer);
9230 }
9231}
9232
9233impl SseEncode for crate::model::RefundableSwap {
9234 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9236 <String>::sse_encode(self.swap_address, serializer);
9237 <u32>::sse_encode(self.timestamp, serializer);
9238 <u64>::sse_encode(self.amount_sat, serializer);
9239 <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9240 }
9241}
9242
9243impl SseEncode for crate::model::RestoreRequest {
9244 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9246 <Option<String>>::sse_encode(self.backup_path, serializer);
9247 }
9248}
9249
9250impl SseEncode for crate::bindings::RouteHint {
9251 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9253 <Vec<crate::bindings::RouteHintHop>>::sse_encode(self.hops, serializer);
9254 }
9255}
9256
9257impl SseEncode for crate::bindings::RouteHintHop {
9258 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9260 <String>::sse_encode(self.src_node_id, serializer);
9261 <String>::sse_encode(self.short_channel_id, serializer);
9262 <u32>::sse_encode(self.fees_base_msat, serializer);
9263 <u32>::sse_encode(self.fees_proportional_millionths, serializer);
9264 <u64>::sse_encode(self.cltv_expiry_delta, serializer);
9265 <Option<u64>>::sse_encode(self.htlc_minimum_msat, serializer);
9266 <Option<u64>>::sse_encode(self.htlc_maximum_msat, serializer);
9267 }
9268}
9269
9270impl SseEncode for crate::error::SdkError {
9271 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9273 match self {
9274 crate::error::SdkError::AlreadyStarted => {
9275 <i32>::sse_encode(0, serializer);
9276 }
9277 crate::error::SdkError::Generic { err } => {
9278 <i32>::sse_encode(1, serializer);
9279 <String>::sse_encode(err, serializer);
9280 }
9281 crate::error::SdkError::NotStarted => {
9282 <i32>::sse_encode(2, serializer);
9283 }
9284 crate::error::SdkError::ServiceConnectivity { err } => {
9285 <i32>::sse_encode(3, serializer);
9286 <String>::sse_encode(err, serializer);
9287 }
9288 _ => {
9289 unimplemented!("");
9290 }
9291 }
9292 }
9293}
9294
9295impl SseEncode for crate::model::SdkEvent {
9296 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9298 match self {
9299 crate::model::SdkEvent::PaymentFailed { details } => {
9300 <i32>::sse_encode(0, serializer);
9301 <crate::model::Payment>::sse_encode(details, serializer);
9302 }
9303 crate::model::SdkEvent::PaymentPending { details } => {
9304 <i32>::sse_encode(1, serializer);
9305 <crate::model::Payment>::sse_encode(details, serializer);
9306 }
9307 crate::model::SdkEvent::PaymentRefundable { details } => {
9308 <i32>::sse_encode(2, serializer);
9309 <crate::model::Payment>::sse_encode(details, serializer);
9310 }
9311 crate::model::SdkEvent::PaymentRefunded { details } => {
9312 <i32>::sse_encode(3, serializer);
9313 <crate::model::Payment>::sse_encode(details, serializer);
9314 }
9315 crate::model::SdkEvent::PaymentRefundPending { details } => {
9316 <i32>::sse_encode(4, serializer);
9317 <crate::model::Payment>::sse_encode(details, serializer);
9318 }
9319 crate::model::SdkEvent::PaymentSucceeded { details } => {
9320 <i32>::sse_encode(5, serializer);
9321 <crate::model::Payment>::sse_encode(details, serializer);
9322 }
9323 crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
9324 <i32>::sse_encode(6, serializer);
9325 <crate::model::Payment>::sse_encode(details, serializer);
9326 }
9327 crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
9328 <i32>::sse_encode(7, serializer);
9329 <crate::model::Payment>::sse_encode(details, serializer);
9330 }
9331 crate::model::SdkEvent::Synced => {
9332 <i32>::sse_encode(8, serializer);
9333 }
9334 crate::model::SdkEvent::DataSynced {
9335 did_pull_new_records,
9336 } => {
9337 <i32>::sse_encode(9, serializer);
9338 <bool>::sse_encode(did_pull_new_records, serializer);
9339 }
9340 _ => {
9341 unimplemented!("");
9342 }
9343 }
9344 }
9345}
9346
9347impl SseEncode for crate::model::SendDestination {
9348 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9350 match self {
9351 crate::model::SendDestination::LiquidAddress {
9352 address_data,
9353 bip353_address,
9354 } => {
9355 <i32>::sse_encode(0, serializer);
9356 <crate::bindings::LiquidAddressData>::sse_encode(address_data, serializer);
9357 <Option<String>>::sse_encode(bip353_address, serializer);
9358 }
9359 crate::model::SendDestination::Bolt11 {
9360 invoice,
9361 bip353_address,
9362 } => {
9363 <i32>::sse_encode(1, serializer);
9364 <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
9365 <Option<String>>::sse_encode(bip353_address, serializer);
9366 }
9367 crate::model::SendDestination::Bolt12 {
9368 offer,
9369 receiver_amount_sat,
9370 bip353_address,
9371 } => {
9372 <i32>::sse_encode(2, serializer);
9373 <crate::bindings::LNOffer>::sse_encode(offer, serializer);
9374 <u64>::sse_encode(receiver_amount_sat, serializer);
9375 <Option<String>>::sse_encode(bip353_address, serializer);
9376 }
9377 _ => {
9378 unimplemented!("");
9379 }
9380 }
9381 }
9382}
9383
9384impl SseEncode for crate::model::SendPaymentRequest {
9385 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9387 <crate::model::PrepareSendResponse>::sse_encode(self.prepare_response, serializer);
9388 <Option<bool>>::sse_encode(self.use_asset_fees, serializer);
9389 }
9390}
9391
9392impl SseEncode for crate::model::SendPaymentResponse {
9393 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9395 <crate::model::Payment>::sse_encode(self.payment, serializer);
9396 }
9397}
9398
9399impl SseEncode for crate::model::SignMessageRequest {
9400 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9402 <String>::sse_encode(self.message, serializer);
9403 }
9404}
9405
9406impl SseEncode for crate::model::SignMessageResponse {
9407 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9409 <String>::sse_encode(self.signature, serializer);
9410 }
9411}
9412
9413impl SseEncode for crate::bindings::SuccessAction {
9414 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9416 match self {
9417 crate::bindings::SuccessAction::Aes { data } => {
9418 <i32>::sse_encode(0, serializer);
9419 <crate::bindings::AesSuccessActionData>::sse_encode(data, serializer);
9420 }
9421 crate::bindings::SuccessAction::Message { data } => {
9422 <i32>::sse_encode(1, serializer);
9423 <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9424 }
9425 crate::bindings::SuccessAction::Url { data } => {
9426 <i32>::sse_encode(2, serializer);
9427 <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9428 }
9429 _ => {
9430 unimplemented!("");
9431 }
9432 }
9433 }
9434}
9435
9436impl SseEncode for crate::bindings::SuccessActionProcessed {
9437 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9439 match self {
9440 crate::bindings::SuccessActionProcessed::Aes { result } => {
9441 <i32>::sse_encode(0, serializer);
9442 <crate::bindings::AesSuccessActionDataResult>::sse_encode(result, serializer);
9443 }
9444 crate::bindings::SuccessActionProcessed::Message { data } => {
9445 <i32>::sse_encode(1, serializer);
9446 <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9447 }
9448 crate::bindings::SuccessActionProcessed::Url { data } => {
9449 <i32>::sse_encode(2, serializer);
9450 <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9451 }
9452 _ => {
9453 unimplemented!("");
9454 }
9455 }
9456 }
9457}
9458
9459impl SseEncode for crate::bindings::Symbol {
9460 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9462 <Option<String>>::sse_encode(self.grapheme, serializer);
9463 <Option<String>>::sse_encode(self.template, serializer);
9464 <Option<bool>>::sse_encode(self.rtl, serializer);
9465 <Option<u32>>::sse_encode(self.position, serializer);
9466 }
9467}
9468
9469impl SseEncode for u16 {
9470 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9472 serializer.cursor.write_u16::<NativeEndian>(self).unwrap();
9473 }
9474}
9475
9476impl SseEncode for u32 {
9477 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9479 serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
9480 }
9481}
9482
9483impl SseEncode for u64 {
9484 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9486 serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
9487 }
9488}
9489
9490impl SseEncode for u8 {
9491 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9493 serializer.cursor.write_u8(self).unwrap();
9494 }
9495}
9496
9497impl SseEncode for () {
9498 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
9500}
9501
9502impl SseEncode for crate::bindings::UrlSuccessActionData {
9503 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9505 <String>::sse_encode(self.description, serializer);
9506 <String>::sse_encode(self.url, serializer);
9507 <bool>::sse_encode(self.matches_callback_domain, serializer);
9508 }
9509}
9510
9511impl SseEncode for usize {
9512 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9514 serializer
9515 .cursor
9516 .write_u64::<NativeEndian>(self as _)
9517 .unwrap();
9518 }
9519}
9520
9521impl SseEncode for crate::model::WalletInfo {
9522 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9524 <u64>::sse_encode(self.balance_sat, serializer);
9525 <u64>::sse_encode(self.pending_send_sat, serializer);
9526 <u64>::sse_encode(self.pending_receive_sat, serializer);
9527 <String>::sse_encode(self.fingerprint, serializer);
9528 <String>::sse_encode(self.pubkey, serializer);
9529 <Vec<crate::model::AssetBalance>>::sse_encode(self.asset_balances, serializer);
9530 }
9531}
9532
9533#[cfg(not(target_family = "wasm"))]
9534mod io {
9535 use super::*;
9541 use crate::bindings::*;
9542 use crate::model::EventListener;
9543 use flutter_rust_bridge::for_generated::byteorder::{
9544 NativeEndian, ReadBytesExt, WriteBytesExt,
9545 };
9546 use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
9547 use flutter_rust_bridge::{Handler, IntoIntoDart};
9548
9549 flutter_rust_bridge::frb_generated_boilerplate_io!();
9552
9553 impl CstDecode<flutter_rust_bridge::for_generated::anyhow::Error>
9556 for *mut wire_cst_list_prim_u_8_strict
9557 {
9558 fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error {
9560 unimplemented!()
9561 }
9562 }
9563 impl CstDecode<BindingLiquidSdk> for usize {
9564 fn cst_decode(self) -> BindingLiquidSdk {
9566 flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::<
9567 RustOpaqueNom<
9568 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9569 >,
9570 >::cst_decode(
9571 self
9572 ))
9573 }
9574 }
9575 impl
9576 CstDecode<
9577 RustOpaqueNom<
9578 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9579 >,
9580 > for usize
9581 {
9582 fn cst_decode(
9584 self,
9585 ) -> RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
9586 {
9587 unsafe { decode_rust_opaque_nom(self as _) }
9588 }
9589 }
9590 impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>
9591 for *mut wire_cst_list_prim_u_8_strict
9592 {
9593 fn cst_decode(
9595 self,
9596 ) -> StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
9597 {
9598 let raw: String = self.cst_decode();
9599 StreamSink::deserialize(raw)
9600 }
9601 }
9602 impl CstDecode<StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>>
9603 for *mut wire_cst_list_prim_u_8_strict
9604 {
9605 fn cst_decode(
9607 self,
9608 ) -> StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
9609 {
9610 let raw: String = self.cst_decode();
9611 StreamSink::deserialize(raw)
9612 }
9613 }
9614 impl CstDecode<String> for *mut wire_cst_list_prim_u_8_strict {
9615 fn cst_decode(self) -> String {
9617 let vec: Vec<u8> = self.cst_decode();
9618 String::from_utf8(vec).unwrap()
9619 }
9620 }
9621 impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9622 for wire_cst_accept_payment_proposed_fees_request
9623 {
9624 fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9626 crate::model::AcceptPaymentProposedFeesRequest {
9627 response: self.response.cst_decode(),
9628 }
9629 }
9630 }
9631 impl CstDecode<crate::bindings::AesSuccessActionData> for wire_cst_aes_success_action_data {
9632 fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9634 crate::bindings::AesSuccessActionData {
9635 description: self.description.cst_decode(),
9636 ciphertext: self.ciphertext.cst_decode(),
9637 iv: self.iv.cst_decode(),
9638 }
9639 }
9640 }
9641 impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9642 for wire_cst_aes_success_action_data_decrypted
9643 {
9644 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9646 crate::bindings::AesSuccessActionDataDecrypted {
9647 description: self.description.cst_decode(),
9648 plaintext: self.plaintext.cst_decode(),
9649 }
9650 }
9651 }
9652 impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9653 for wire_cst_aes_success_action_data_result
9654 {
9655 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9657 match self.tag {
9658 0 => {
9659 let ans = unsafe { self.kind.Decrypted };
9660 crate::bindings::AesSuccessActionDataResult::Decrypted {
9661 data: ans.data.cst_decode(),
9662 }
9663 }
9664 1 => {
9665 let ans = unsafe { self.kind.ErrorStatus };
9666 crate::bindings::AesSuccessActionDataResult::ErrorStatus {
9667 reason: ans.reason.cst_decode(),
9668 }
9669 }
9670 _ => unreachable!(),
9671 }
9672 }
9673 }
9674 impl CstDecode<crate::bindings::Amount> for wire_cst_amount {
9675 fn cst_decode(self) -> crate::bindings::Amount {
9677 match self.tag {
9678 0 => {
9679 let ans = unsafe { self.kind.Bitcoin };
9680 crate::bindings::Amount::Bitcoin {
9681 amount_msat: ans.amount_msat.cst_decode(),
9682 }
9683 }
9684 1 => {
9685 let ans = unsafe { self.kind.Currency };
9686 crate::bindings::Amount::Currency {
9687 iso4217_code: ans.iso4217_code.cst_decode(),
9688 fractional_amount: ans.fractional_amount.cst_decode(),
9689 }
9690 }
9691 _ => unreachable!(),
9692 }
9693 }
9694 }
9695 impl CstDecode<crate::model::AssetBalance> for wire_cst_asset_balance {
9696 fn cst_decode(self) -> crate::model::AssetBalance {
9698 crate::model::AssetBalance {
9699 asset_id: self.asset_id.cst_decode(),
9700 balance_sat: self.balance_sat.cst_decode(),
9701 name: self.name.cst_decode(),
9702 ticker: self.ticker.cst_decode(),
9703 balance: self.balance.cst_decode(),
9704 }
9705 }
9706 }
9707 impl CstDecode<crate::model::AssetInfo> for wire_cst_asset_info {
9708 fn cst_decode(self) -> crate::model::AssetInfo {
9710 crate::model::AssetInfo {
9711 name: self.name.cst_decode(),
9712 ticker: self.ticker.cst_decode(),
9713 amount: self.amount.cst_decode(),
9714 fees: self.fees.cst_decode(),
9715 }
9716 }
9717 }
9718 impl CstDecode<crate::model::AssetMetadata> for wire_cst_asset_metadata {
9719 fn cst_decode(self) -> crate::model::AssetMetadata {
9721 crate::model::AssetMetadata {
9722 asset_id: self.asset_id.cst_decode(),
9723 name: self.name.cst_decode(),
9724 ticker: self.ticker.cst_decode(),
9725 precision: self.precision.cst_decode(),
9726 fiat_id: self.fiat_id.cst_decode(),
9727 }
9728 }
9729 }
9730 impl CstDecode<crate::model::BackupRequest> for wire_cst_backup_request {
9731 fn cst_decode(self) -> crate::model::BackupRequest {
9733 crate::model::BackupRequest {
9734 backup_path: self.backup_path.cst_decode(),
9735 }
9736 }
9737 }
9738 impl CstDecode<crate::bindings::BindingEventListener> for wire_cst_binding_event_listener {
9739 fn cst_decode(self) -> crate::bindings::BindingEventListener {
9741 crate::bindings::BindingEventListener {
9742 stream: self.stream.cst_decode(),
9743 }
9744 }
9745 }
9746 impl CstDecode<crate::bindings::BitcoinAddressData> for wire_cst_bitcoin_address_data {
9747 fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9749 crate::bindings::BitcoinAddressData {
9750 address: self.address.cst_decode(),
9751 network: self.network.cst_decode(),
9752 amount_sat: self.amount_sat.cst_decode(),
9753 label: self.label.cst_decode(),
9754 message: self.message.cst_decode(),
9755 }
9756 }
9757 }
9758 impl CstDecode<crate::model::BlockchainExplorer> for wire_cst_blockchain_explorer {
9759 fn cst_decode(self) -> crate::model::BlockchainExplorer {
9761 match self.tag {
9762 0 => {
9763 let ans = unsafe { self.kind.Electrum };
9764 crate::model::BlockchainExplorer::Electrum {
9765 url: ans.url.cst_decode(),
9766 }
9767 }
9768 1 => {
9769 let ans = unsafe { self.kind.Esplora };
9770 crate::model::BlockchainExplorer::Esplora {
9771 url: ans.url.cst_decode(),
9772 use_waterfalls: ans.use_waterfalls.cst_decode(),
9773 }
9774 }
9775 _ => unreachable!(),
9776 }
9777 }
9778 }
9779 impl CstDecode<crate::model::BlockchainInfo> for wire_cst_blockchain_info {
9780 fn cst_decode(self) -> crate::model::BlockchainInfo {
9782 crate::model::BlockchainInfo {
9783 liquid_tip: self.liquid_tip.cst_decode(),
9784 bitcoin_tip: self.bitcoin_tip.cst_decode(),
9785 }
9786 }
9787 }
9788 impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9789 for *mut wire_cst_accept_payment_proposed_fees_request
9790 {
9791 fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9793 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9794 CstDecode::<crate::model::AcceptPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9795 }
9796 }
9797 impl CstDecode<crate::bindings::AesSuccessActionData> for *mut wire_cst_aes_success_action_data {
9798 fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9800 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9801 CstDecode::<crate::bindings::AesSuccessActionData>::cst_decode(*wrap).into()
9802 }
9803 }
9804 impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9805 for *mut wire_cst_aes_success_action_data_decrypted
9806 {
9807 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9809 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9810 CstDecode::<crate::bindings::AesSuccessActionDataDecrypted>::cst_decode(*wrap).into()
9811 }
9812 }
9813 impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9814 for *mut wire_cst_aes_success_action_data_result
9815 {
9816 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9818 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9819 CstDecode::<crate::bindings::AesSuccessActionDataResult>::cst_decode(*wrap).into()
9820 }
9821 }
9822 impl CstDecode<crate::bindings::Amount> for *mut wire_cst_amount {
9823 fn cst_decode(self) -> crate::bindings::Amount {
9825 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9826 CstDecode::<crate::bindings::Amount>::cst_decode(*wrap).into()
9827 }
9828 }
9829 impl CstDecode<crate::model::AssetInfo> for *mut wire_cst_asset_info {
9830 fn cst_decode(self) -> crate::model::AssetInfo {
9832 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9833 CstDecode::<crate::model::AssetInfo>::cst_decode(*wrap).into()
9834 }
9835 }
9836 impl CstDecode<crate::model::BackupRequest> for *mut wire_cst_backup_request {
9837 fn cst_decode(self) -> crate::model::BackupRequest {
9839 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9840 CstDecode::<crate::model::BackupRequest>::cst_decode(*wrap).into()
9841 }
9842 }
9843 impl CstDecode<crate::bindings::BindingEventListener> for *mut wire_cst_binding_event_listener {
9844 fn cst_decode(self) -> crate::bindings::BindingEventListener {
9846 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9847 CstDecode::<crate::bindings::BindingEventListener>::cst_decode(*wrap).into()
9848 }
9849 }
9850 impl CstDecode<crate::bindings::BitcoinAddressData> for *mut wire_cst_bitcoin_address_data {
9851 fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9853 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9854 CstDecode::<crate::bindings::BitcoinAddressData>::cst_decode(*wrap).into()
9855 }
9856 }
9857 impl CstDecode<bool> for *mut bool {
9858 fn cst_decode(self) -> bool {
9860 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9861 }
9862 }
9863 impl CstDecode<crate::model::BuyBitcoinRequest> for *mut wire_cst_buy_bitcoin_request {
9864 fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
9866 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9867 CstDecode::<crate::model::BuyBitcoinRequest>::cst_decode(*wrap).into()
9868 }
9869 }
9870 impl CstDecode<crate::model::CheckMessageRequest> for *mut wire_cst_check_message_request {
9871 fn cst_decode(self) -> crate::model::CheckMessageRequest {
9873 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9874 CstDecode::<crate::model::CheckMessageRequest>::cst_decode(*wrap).into()
9875 }
9876 }
9877 impl CstDecode<crate::model::ConnectRequest> for *mut wire_cst_connect_request {
9878 fn cst_decode(self) -> crate::model::ConnectRequest {
9880 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9881 CstDecode::<crate::model::ConnectRequest>::cst_decode(*wrap).into()
9882 }
9883 }
9884 impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
9885 for *mut wire_cst_create_bolt_12_invoice_request
9886 {
9887 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
9889 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9890 CstDecode::<crate::model::CreateBolt12InvoiceRequest>::cst_decode(*wrap).into()
9891 }
9892 }
9893 impl CstDecode<f64> for *mut f64 {
9894 fn cst_decode(self) -> f64 {
9896 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9897 }
9898 }
9899 impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
9900 for *mut wire_cst_fetch_payment_proposed_fees_request
9901 {
9902 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
9904 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9905 CstDecode::<crate::model::FetchPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9906 }
9907 }
9908 impl CstDecode<crate::model::GetPaymentRequest> for *mut wire_cst_get_payment_request {
9909 fn cst_decode(self) -> crate::model::GetPaymentRequest {
9911 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9912 CstDecode::<crate::model::GetPaymentRequest>::cst_decode(*wrap).into()
9913 }
9914 }
9915 impl CstDecode<i64> for *mut i64 {
9916 fn cst_decode(self) -> i64 {
9918 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9919 }
9920 }
9921 impl CstDecode<crate::bindings::LiquidAddressData> for *mut wire_cst_liquid_address_data {
9922 fn cst_decode(self) -> crate::bindings::LiquidAddressData {
9924 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9925 CstDecode::<crate::bindings::LiquidAddressData>::cst_decode(*wrap).into()
9926 }
9927 }
9928 impl CstDecode<crate::model::ListPaymentDetails> for *mut wire_cst_list_payment_details {
9929 fn cst_decode(self) -> crate::model::ListPaymentDetails {
9931 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9932 CstDecode::<crate::model::ListPaymentDetails>::cst_decode(*wrap).into()
9933 }
9934 }
9935 impl CstDecode<crate::model::ListPaymentsRequest> for *mut wire_cst_list_payments_request {
9936 fn cst_decode(self) -> crate::model::ListPaymentsRequest {
9938 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9939 CstDecode::<crate::model::ListPaymentsRequest>::cst_decode(*wrap).into()
9940 }
9941 }
9942 impl CstDecode<crate::bindings::LNInvoice> for *mut wire_cst_ln_invoice {
9943 fn cst_decode(self) -> crate::bindings::LNInvoice {
9945 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9946 CstDecode::<crate::bindings::LNInvoice>::cst_decode(*wrap).into()
9947 }
9948 }
9949 impl CstDecode<crate::bindings::LNOffer> for *mut wire_cst_ln_offer {
9950 fn cst_decode(self) -> crate::bindings::LNOffer {
9952 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9953 CstDecode::<crate::bindings::LNOffer>::cst_decode(*wrap).into()
9954 }
9955 }
9956 impl CstDecode<crate::bindings::LnUrlAuthRequestData> for *mut wire_cst_ln_url_auth_request_data {
9957 fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
9959 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9960 CstDecode::<crate::bindings::LnUrlAuthRequestData>::cst_decode(*wrap).into()
9961 }
9962 }
9963 impl CstDecode<crate::bindings::LnUrlErrorData> for *mut wire_cst_ln_url_error_data {
9964 fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
9966 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9967 CstDecode::<crate::bindings::LnUrlErrorData>::cst_decode(*wrap).into()
9968 }
9969 }
9970 impl CstDecode<crate::model::LnUrlInfo> for *mut wire_cst_ln_url_info {
9971 fn cst_decode(self) -> crate::model::LnUrlInfo {
9973 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9974 CstDecode::<crate::model::LnUrlInfo>::cst_decode(*wrap).into()
9975 }
9976 }
9977 impl CstDecode<crate::bindings::LnUrlPayErrorData> for *mut wire_cst_ln_url_pay_error_data {
9978 fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
9980 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9981 CstDecode::<crate::bindings::LnUrlPayErrorData>::cst_decode(*wrap).into()
9982 }
9983 }
9984 impl CstDecode<crate::model::LnUrlPayRequest> for *mut wire_cst_ln_url_pay_request {
9985 fn cst_decode(self) -> crate::model::LnUrlPayRequest {
9987 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9988 CstDecode::<crate::model::LnUrlPayRequest>::cst_decode(*wrap).into()
9989 }
9990 }
9991 impl CstDecode<crate::bindings::LnUrlPayRequestData> for *mut wire_cst_ln_url_pay_request_data {
9992 fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
9994 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9995 CstDecode::<crate::bindings::LnUrlPayRequestData>::cst_decode(*wrap).into()
9996 }
9997 }
9998 impl CstDecode<crate::model::LnUrlPaySuccessData> for *mut wire_cst_ln_url_pay_success_data {
9999 fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10001 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10002 CstDecode::<crate::model::LnUrlPaySuccessData>::cst_decode(*wrap).into()
10003 }
10004 }
10005 impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for *mut wire_cst_ln_url_withdraw_request {
10006 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
10008 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10009 CstDecode::<crate::bindings::LnUrlWithdrawRequest>::cst_decode(*wrap).into()
10010 }
10011 }
10012 impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
10013 for *mut wire_cst_ln_url_withdraw_request_data
10014 {
10015 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
10017 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10018 CstDecode::<crate::bindings::LnUrlWithdrawRequestData>::cst_decode(*wrap).into()
10019 }
10020 }
10021 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
10022 for *mut wire_cst_ln_url_withdraw_success_data
10023 {
10024 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
10026 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10027 CstDecode::<crate::bindings::duplicates::LnUrlWithdrawSuccessData>::cst_decode(*wrap)
10028 .into()
10029 }
10030 }
10031 impl CstDecode<crate::bindings::MessageSuccessActionData>
10032 for *mut wire_cst_message_success_action_data
10033 {
10034 fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
10036 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10037 CstDecode::<crate::bindings::MessageSuccessActionData>::cst_decode(*wrap).into()
10038 }
10039 }
10040 impl CstDecode<crate::model::PayAmount> for *mut wire_cst_pay_amount {
10041 fn cst_decode(self) -> crate::model::PayAmount {
10043 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10044 CstDecode::<crate::model::PayAmount>::cst_decode(*wrap).into()
10045 }
10046 }
10047 impl CstDecode<crate::model::PayOnchainRequest> for *mut wire_cst_pay_onchain_request {
10048 fn cst_decode(self) -> crate::model::PayOnchainRequest {
10050 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10051 CstDecode::<crate::model::PayOnchainRequest>::cst_decode(*wrap).into()
10052 }
10053 }
10054 impl CstDecode<crate::model::Payment> for *mut wire_cst_payment {
10055 fn cst_decode(self) -> crate::model::Payment {
10057 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10058 CstDecode::<crate::model::Payment>::cst_decode(*wrap).into()
10059 }
10060 }
10061 impl CstDecode<crate::model::PrepareBuyBitcoinRequest>
10062 for *mut wire_cst_prepare_buy_bitcoin_request
10063 {
10064 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
10066 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10067 CstDecode::<crate::model::PrepareBuyBitcoinRequest>::cst_decode(*wrap).into()
10068 }
10069 }
10070 impl CstDecode<crate::model::PrepareLnUrlPayRequest> for *mut wire_cst_prepare_ln_url_pay_request {
10071 fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
10073 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10074 CstDecode::<crate::model::PrepareLnUrlPayRequest>::cst_decode(*wrap).into()
10075 }
10076 }
10077 impl CstDecode<crate::model::PreparePayOnchainRequest>
10078 for *mut wire_cst_prepare_pay_onchain_request
10079 {
10080 fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
10082 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10083 CstDecode::<crate::model::PreparePayOnchainRequest>::cst_decode(*wrap).into()
10084 }
10085 }
10086 impl CstDecode<crate::model::PrepareReceiveRequest> for *mut wire_cst_prepare_receive_request {
10087 fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
10089 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10090 CstDecode::<crate::model::PrepareReceiveRequest>::cst_decode(*wrap).into()
10091 }
10092 }
10093 impl CstDecode<crate::model::PrepareRefundRequest> for *mut wire_cst_prepare_refund_request {
10094 fn cst_decode(self) -> crate::model::PrepareRefundRequest {
10096 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10097 CstDecode::<crate::model::PrepareRefundRequest>::cst_decode(*wrap).into()
10098 }
10099 }
10100 impl CstDecode<crate::model::PrepareSendRequest> for *mut wire_cst_prepare_send_request {
10101 fn cst_decode(self) -> crate::model::PrepareSendRequest {
10103 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10104 CstDecode::<crate::model::PrepareSendRequest>::cst_decode(*wrap).into()
10105 }
10106 }
10107 impl CstDecode<crate::model::ReceiveAmount> for *mut wire_cst_receive_amount {
10108 fn cst_decode(self) -> crate::model::ReceiveAmount {
10110 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10111 CstDecode::<crate::model::ReceiveAmount>::cst_decode(*wrap).into()
10112 }
10113 }
10114 impl CstDecode<crate::model::ReceivePaymentRequest> for *mut wire_cst_receive_payment_request {
10115 fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
10117 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10118 CstDecode::<crate::model::ReceivePaymentRequest>::cst_decode(*wrap).into()
10119 }
10120 }
10121 impl CstDecode<crate::model::RefundRequest> for *mut wire_cst_refund_request {
10122 fn cst_decode(self) -> crate::model::RefundRequest {
10124 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10125 CstDecode::<crate::model::RefundRequest>::cst_decode(*wrap).into()
10126 }
10127 }
10128 impl CstDecode<crate::model::RestoreRequest> for *mut wire_cst_restore_request {
10129 fn cst_decode(self) -> crate::model::RestoreRequest {
10131 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10132 CstDecode::<crate::model::RestoreRequest>::cst_decode(*wrap).into()
10133 }
10134 }
10135 impl CstDecode<crate::model::SdkEvent> for *mut wire_cst_sdk_event {
10136 fn cst_decode(self) -> crate::model::SdkEvent {
10138 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10139 CstDecode::<crate::model::SdkEvent>::cst_decode(*wrap).into()
10140 }
10141 }
10142 impl CstDecode<crate::model::SendPaymentRequest> for *mut wire_cst_send_payment_request {
10143 fn cst_decode(self) -> crate::model::SendPaymentRequest {
10145 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10146 CstDecode::<crate::model::SendPaymentRequest>::cst_decode(*wrap).into()
10147 }
10148 }
10149 impl CstDecode<crate::model::SignMessageRequest> for *mut wire_cst_sign_message_request {
10150 fn cst_decode(self) -> crate::model::SignMessageRequest {
10152 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10153 CstDecode::<crate::model::SignMessageRequest>::cst_decode(*wrap).into()
10154 }
10155 }
10156 impl CstDecode<crate::bindings::SuccessAction> for *mut wire_cst_success_action {
10157 fn cst_decode(self) -> crate::bindings::SuccessAction {
10159 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10160 CstDecode::<crate::bindings::SuccessAction>::cst_decode(*wrap).into()
10161 }
10162 }
10163 impl CstDecode<crate::bindings::SuccessActionProcessed> for *mut wire_cst_success_action_processed {
10164 fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
10166 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10167 CstDecode::<crate::bindings::SuccessActionProcessed>::cst_decode(*wrap).into()
10168 }
10169 }
10170 impl CstDecode<crate::bindings::Symbol> for *mut wire_cst_symbol {
10171 fn cst_decode(self) -> crate::bindings::Symbol {
10173 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10174 CstDecode::<crate::bindings::Symbol>::cst_decode(*wrap).into()
10175 }
10176 }
10177 impl CstDecode<u32> for *mut u32 {
10178 fn cst_decode(self) -> u32 {
10180 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10181 }
10182 }
10183 impl CstDecode<u64> for *mut u64 {
10184 fn cst_decode(self) -> u64 {
10186 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10187 }
10188 }
10189 impl CstDecode<crate::bindings::UrlSuccessActionData> for *mut wire_cst_url_success_action_data {
10190 fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
10192 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10193 CstDecode::<crate::bindings::UrlSuccessActionData>::cst_decode(*wrap).into()
10194 }
10195 }
10196 impl CstDecode<crate::model::BuyBitcoinRequest> for wire_cst_buy_bitcoin_request {
10197 fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
10199 crate::model::BuyBitcoinRequest {
10200 prepare_response: self.prepare_response.cst_decode(),
10201 redirect_url: self.redirect_url.cst_decode(),
10202 }
10203 }
10204 }
10205 impl CstDecode<crate::model::CheckMessageRequest> for wire_cst_check_message_request {
10206 fn cst_decode(self) -> crate::model::CheckMessageRequest {
10208 crate::model::CheckMessageRequest {
10209 message: self.message.cst_decode(),
10210 pubkey: self.pubkey.cst_decode(),
10211 signature: self.signature.cst_decode(),
10212 }
10213 }
10214 }
10215 impl CstDecode<crate::model::CheckMessageResponse> for wire_cst_check_message_response {
10216 fn cst_decode(self) -> crate::model::CheckMessageResponse {
10218 crate::model::CheckMessageResponse {
10219 is_valid: self.is_valid.cst_decode(),
10220 }
10221 }
10222 }
10223 impl CstDecode<crate::model::Config> for wire_cst_config {
10224 fn cst_decode(self) -> crate::model::Config {
10226 crate::model::Config {
10227 liquid_explorer: self.liquid_explorer.cst_decode(),
10228 bitcoin_explorer: self.bitcoin_explorer.cst_decode(),
10229 working_dir: self.working_dir.cst_decode(),
10230 cache_dir: self.cache_dir.cst_decode(),
10231 network: self.network.cst_decode(),
10232 payment_timeout_sec: self.payment_timeout_sec.cst_decode(),
10233 sync_service_url: self.sync_service_url.cst_decode(),
10234 zero_conf_max_amount_sat: self.zero_conf_max_amount_sat.cst_decode(),
10235 breez_api_key: self.breez_api_key.cst_decode(),
10236 external_input_parsers: self.external_input_parsers.cst_decode(),
10237 use_default_external_input_parsers: self
10238 .use_default_external_input_parsers
10239 .cst_decode(),
10240 onchain_fee_rate_leeway_sat_per_vbyte: self
10241 .onchain_fee_rate_leeway_sat_per_vbyte
10242 .cst_decode(),
10243 asset_metadata: self.asset_metadata.cst_decode(),
10244 sideswap_api_key: self.sideswap_api_key.cst_decode(),
10245 }
10246 }
10247 }
10248 impl CstDecode<crate::model::ConnectRequest> for wire_cst_connect_request {
10249 fn cst_decode(self) -> crate::model::ConnectRequest {
10251 crate::model::ConnectRequest {
10252 config: self.config.cst_decode(),
10253 mnemonic: self.mnemonic.cst_decode(),
10254 passphrase: self.passphrase.cst_decode(),
10255 seed: self.seed.cst_decode(),
10256 }
10257 }
10258 }
10259 impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
10260 for wire_cst_create_bolt_12_invoice_request
10261 {
10262 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
10264 crate::model::CreateBolt12InvoiceRequest {
10265 offer: self.offer.cst_decode(),
10266 invoice_request: self.invoice_request.cst_decode(),
10267 }
10268 }
10269 }
10270 impl CstDecode<crate::model::CreateBolt12InvoiceResponse>
10271 for wire_cst_create_bolt_12_invoice_response
10272 {
10273 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceResponse {
10275 crate::model::CreateBolt12InvoiceResponse {
10276 invoice: self.invoice.cst_decode(),
10277 }
10278 }
10279 }
10280 impl CstDecode<crate::bindings::CurrencyInfo> for wire_cst_currency_info {
10281 fn cst_decode(self) -> crate::bindings::CurrencyInfo {
10283 crate::bindings::CurrencyInfo {
10284 name: self.name.cst_decode(),
10285 fraction_size: self.fraction_size.cst_decode(),
10286 spacing: self.spacing.cst_decode(),
10287 symbol: self.symbol.cst_decode(),
10288 uniq_symbol: self.uniq_symbol.cst_decode(),
10289 localized_name: self.localized_name.cst_decode(),
10290 locale_overrides: self.locale_overrides.cst_decode(),
10291 }
10292 }
10293 }
10294 impl CstDecode<crate::bindings::ExternalInputParser> for wire_cst_external_input_parser {
10295 fn cst_decode(self) -> crate::bindings::ExternalInputParser {
10297 crate::bindings::ExternalInputParser {
10298 provider_id: self.provider_id.cst_decode(),
10299 input_regex: self.input_regex.cst_decode(),
10300 parser_url: self.parser_url.cst_decode(),
10301 }
10302 }
10303 }
10304 impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
10305 for wire_cst_fetch_payment_proposed_fees_request
10306 {
10307 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
10309 crate::model::FetchPaymentProposedFeesRequest {
10310 swap_id: self.swap_id.cst_decode(),
10311 }
10312 }
10313 }
10314 impl CstDecode<crate::model::FetchPaymentProposedFeesResponse>
10315 for wire_cst_fetch_payment_proposed_fees_response
10316 {
10317 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesResponse {
10319 crate::model::FetchPaymentProposedFeesResponse {
10320 swap_id: self.swap_id.cst_decode(),
10321 fees_sat: self.fees_sat.cst_decode(),
10322 payer_amount_sat: self.payer_amount_sat.cst_decode(),
10323 receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
10324 }
10325 }
10326 }
10327 impl CstDecode<crate::bindings::FiatCurrency> for wire_cst_fiat_currency {
10328 fn cst_decode(self) -> crate::bindings::FiatCurrency {
10330 crate::bindings::FiatCurrency {
10331 id: self.id.cst_decode(),
10332 info: self.info.cst_decode(),
10333 }
10334 }
10335 }
10336 impl CstDecode<crate::model::GetInfoResponse> for wire_cst_get_info_response {
10337 fn cst_decode(self) -> crate::model::GetInfoResponse {
10339 crate::model::GetInfoResponse {
10340 wallet_info: self.wallet_info.cst_decode(),
10341 blockchain_info: self.blockchain_info.cst_decode(),
10342 }
10343 }
10344 }
10345 impl CstDecode<crate::model::GetPaymentRequest> for wire_cst_get_payment_request {
10346 fn cst_decode(self) -> crate::model::GetPaymentRequest {
10348 match self.tag {
10349 0 => {
10350 let ans = unsafe { self.kind.PaymentHash };
10351 crate::model::GetPaymentRequest::PaymentHash {
10352 payment_hash: ans.payment_hash.cst_decode(),
10353 }
10354 }
10355 1 => {
10356 let ans = unsafe { self.kind.SwapId };
10357 crate::model::GetPaymentRequest::SwapId {
10358 swap_id: ans.swap_id.cst_decode(),
10359 }
10360 }
10361 _ => unreachable!(),
10362 }
10363 }
10364 }
10365 impl CstDecode<crate::bindings::InputType> for wire_cst_input_type {
10366 fn cst_decode(self) -> crate::bindings::InputType {
10368 match self.tag {
10369 0 => {
10370 let ans = unsafe { self.kind.BitcoinAddress };
10371 crate::bindings::InputType::BitcoinAddress {
10372 address: ans.address.cst_decode(),
10373 }
10374 }
10375 1 => {
10376 let ans = unsafe { self.kind.LiquidAddress };
10377 crate::bindings::InputType::LiquidAddress {
10378 address: ans.address.cst_decode(),
10379 }
10380 }
10381 2 => {
10382 let ans = unsafe { self.kind.Bolt11 };
10383 crate::bindings::InputType::Bolt11 {
10384 invoice: ans.invoice.cst_decode(),
10385 }
10386 }
10387 3 => {
10388 let ans = unsafe { self.kind.Bolt12Offer };
10389 crate::bindings::InputType::Bolt12Offer {
10390 offer: ans.offer.cst_decode(),
10391 bip353_address: ans.bip353_address.cst_decode(),
10392 }
10393 }
10394 4 => {
10395 let ans = unsafe { self.kind.NodeId };
10396 crate::bindings::InputType::NodeId {
10397 node_id: ans.node_id.cst_decode(),
10398 }
10399 }
10400 5 => {
10401 let ans = unsafe { self.kind.Url };
10402 crate::bindings::InputType::Url {
10403 url: ans.url.cst_decode(),
10404 }
10405 }
10406 6 => {
10407 let ans = unsafe { self.kind.LnUrlPay };
10408 crate::bindings::InputType::LnUrlPay {
10409 data: ans.data.cst_decode(),
10410 bip353_address: ans.bip353_address.cst_decode(),
10411 }
10412 }
10413 7 => {
10414 let ans = unsafe { self.kind.LnUrlWithdraw };
10415 crate::bindings::InputType::LnUrlWithdraw {
10416 data: ans.data.cst_decode(),
10417 }
10418 }
10419 8 => {
10420 let ans = unsafe { self.kind.LnUrlAuth };
10421 crate::bindings::InputType::LnUrlAuth {
10422 data: ans.data.cst_decode(),
10423 }
10424 }
10425 9 => {
10426 let ans = unsafe { self.kind.LnUrlError };
10427 crate::bindings::InputType::LnUrlError {
10428 data: ans.data.cst_decode(),
10429 }
10430 }
10431 _ => unreachable!(),
10432 }
10433 }
10434 }
10435 impl CstDecode<crate::model::LightningPaymentLimitsResponse>
10436 for wire_cst_lightning_payment_limits_response
10437 {
10438 fn cst_decode(self) -> crate::model::LightningPaymentLimitsResponse {
10440 crate::model::LightningPaymentLimitsResponse {
10441 send: self.send.cst_decode(),
10442 receive: self.receive.cst_decode(),
10443 }
10444 }
10445 }
10446 impl CstDecode<crate::model::Limits> for wire_cst_limits {
10447 fn cst_decode(self) -> crate::model::Limits {
10449 crate::model::Limits {
10450 min_sat: self.min_sat.cst_decode(),
10451 max_sat: self.max_sat.cst_decode(),
10452 max_zero_conf_sat: self.max_zero_conf_sat.cst_decode(),
10453 }
10454 }
10455 }
10456 impl CstDecode<crate::bindings::LiquidAddressData> for wire_cst_liquid_address_data {
10457 fn cst_decode(self) -> crate::bindings::LiquidAddressData {
10459 crate::bindings::LiquidAddressData {
10460 address: self.address.cst_decode(),
10461 network: self.network.cst_decode(),
10462 asset_id: self.asset_id.cst_decode(),
10463 amount: self.amount.cst_decode(),
10464 amount_sat: self.amount_sat.cst_decode(),
10465 label: self.label.cst_decode(),
10466 message: self.message.cst_decode(),
10467 }
10468 }
10469 }
10470 impl CstDecode<Vec<String>> for *mut wire_cst_list_String {
10471 fn cst_decode(self) -> Vec<String> {
10473 let vec = unsafe {
10474 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10475 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10476 };
10477 vec.into_iter().map(CstDecode::cst_decode).collect()
10478 }
10479 }
10480 impl CstDecode<Vec<crate::model::AssetBalance>> for *mut wire_cst_list_asset_balance {
10481 fn cst_decode(self) -> Vec<crate::model::AssetBalance> {
10483 let vec = unsafe {
10484 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10485 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10486 };
10487 vec.into_iter().map(CstDecode::cst_decode).collect()
10488 }
10489 }
10490 impl CstDecode<Vec<crate::model::AssetMetadata>> for *mut wire_cst_list_asset_metadata {
10491 fn cst_decode(self) -> Vec<crate::model::AssetMetadata> {
10493 let vec = unsafe {
10494 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10495 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10496 };
10497 vec.into_iter().map(CstDecode::cst_decode).collect()
10498 }
10499 }
10500 impl CstDecode<Vec<crate::bindings::ExternalInputParser>>
10501 for *mut wire_cst_list_external_input_parser
10502 {
10503 fn cst_decode(self) -> Vec<crate::bindings::ExternalInputParser> {
10505 let vec = unsafe {
10506 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10507 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10508 };
10509 vec.into_iter().map(CstDecode::cst_decode).collect()
10510 }
10511 }
10512 impl CstDecode<Vec<crate::bindings::FiatCurrency>> for *mut wire_cst_list_fiat_currency {
10513 fn cst_decode(self) -> Vec<crate::bindings::FiatCurrency> {
10515 let vec = unsafe {
10516 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10517 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10518 };
10519 vec.into_iter().map(CstDecode::cst_decode).collect()
10520 }
10521 }
10522 impl CstDecode<Vec<crate::bindings::LnOfferBlindedPath>>
10523 for *mut wire_cst_list_ln_offer_blinded_path
10524 {
10525 fn cst_decode(self) -> Vec<crate::bindings::LnOfferBlindedPath> {
10527 let vec = unsafe {
10528 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10529 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10530 };
10531 vec.into_iter().map(CstDecode::cst_decode).collect()
10532 }
10533 }
10534 impl CstDecode<Vec<crate::bindings::LocaleOverrides>> for *mut wire_cst_list_locale_overrides {
10535 fn cst_decode(self) -> Vec<crate::bindings::LocaleOverrides> {
10537 let vec = unsafe {
10538 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10539 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10540 };
10541 vec.into_iter().map(CstDecode::cst_decode).collect()
10542 }
10543 }
10544 impl CstDecode<Vec<crate::bindings::LocalizedName>> for *mut wire_cst_list_localized_name {
10545 fn cst_decode(self) -> Vec<crate::bindings::LocalizedName> {
10547 let vec = unsafe {
10548 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10549 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10550 };
10551 vec.into_iter().map(CstDecode::cst_decode).collect()
10552 }
10553 }
10554 impl CstDecode<Vec<crate::model::Payment>> for *mut wire_cst_list_payment {
10555 fn cst_decode(self) -> Vec<crate::model::Payment> {
10557 let vec = unsafe {
10558 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10559 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10560 };
10561 vec.into_iter().map(CstDecode::cst_decode).collect()
10562 }
10563 }
10564 impl CstDecode<crate::model::ListPaymentDetails> for wire_cst_list_payment_details {
10565 fn cst_decode(self) -> crate::model::ListPaymentDetails {
10567 match self.tag {
10568 0 => {
10569 let ans = unsafe { self.kind.Liquid };
10570 crate::model::ListPaymentDetails::Liquid {
10571 asset_id: ans.asset_id.cst_decode(),
10572 destination: ans.destination.cst_decode(),
10573 }
10574 }
10575 1 => {
10576 let ans = unsafe { self.kind.Bitcoin };
10577 crate::model::ListPaymentDetails::Bitcoin {
10578 address: ans.address.cst_decode(),
10579 }
10580 }
10581 _ => unreachable!(),
10582 }
10583 }
10584 }
10585 impl CstDecode<Vec<crate::model::PaymentState>> for *mut wire_cst_list_payment_state {
10586 fn cst_decode(self) -> Vec<crate::model::PaymentState> {
10588 let vec = unsafe {
10589 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10590 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10591 };
10592 vec.into_iter().map(CstDecode::cst_decode).collect()
10593 }
10594 }
10595 impl CstDecode<Vec<crate::model::PaymentType>> for *mut wire_cst_list_payment_type {
10596 fn cst_decode(self) -> Vec<crate::model::PaymentType> {
10598 let vec = unsafe {
10599 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10600 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10601 };
10602 vec.into_iter().map(CstDecode::cst_decode).collect()
10603 }
10604 }
10605 impl CstDecode<crate::model::ListPaymentsRequest> for wire_cst_list_payments_request {
10606 fn cst_decode(self) -> crate::model::ListPaymentsRequest {
10608 crate::model::ListPaymentsRequest {
10609 filters: self.filters.cst_decode(),
10610 states: self.states.cst_decode(),
10611 from_timestamp: self.from_timestamp.cst_decode(),
10612 to_timestamp: self.to_timestamp.cst_decode(),
10613 offset: self.offset.cst_decode(),
10614 limit: self.limit.cst_decode(),
10615 details: self.details.cst_decode(),
10616 sort_ascending: self.sort_ascending.cst_decode(),
10617 }
10618 }
10619 }
10620 impl CstDecode<Vec<u8>> for *mut wire_cst_list_prim_u_8_strict {
10621 fn cst_decode(self) -> Vec<u8> {
10623 unsafe {
10624 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10625 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10626 }
10627 }
10628 }
10629 impl CstDecode<Vec<crate::bindings::Rate>> for *mut wire_cst_list_rate {
10630 fn cst_decode(self) -> Vec<crate::bindings::Rate> {
10632 let vec = unsafe {
10633 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10634 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10635 };
10636 vec.into_iter().map(CstDecode::cst_decode).collect()
10637 }
10638 }
10639 impl CstDecode<Vec<crate::model::RefundableSwap>> for *mut wire_cst_list_refundable_swap {
10640 fn cst_decode(self) -> Vec<crate::model::RefundableSwap> {
10642 let vec = unsafe {
10643 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10644 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10645 };
10646 vec.into_iter().map(CstDecode::cst_decode).collect()
10647 }
10648 }
10649 impl CstDecode<Vec<crate::bindings::RouteHint>> for *mut wire_cst_list_route_hint {
10650 fn cst_decode(self) -> Vec<crate::bindings::RouteHint> {
10652 let vec = unsafe {
10653 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10654 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10655 };
10656 vec.into_iter().map(CstDecode::cst_decode).collect()
10657 }
10658 }
10659 impl CstDecode<Vec<crate::bindings::RouteHintHop>> for *mut wire_cst_list_route_hint_hop {
10660 fn cst_decode(self) -> Vec<crate::bindings::RouteHintHop> {
10662 let vec = 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 vec.into_iter().map(CstDecode::cst_decode).collect()
10667 }
10668 }
10669 impl CstDecode<crate::bindings::LNInvoice> for wire_cst_ln_invoice {
10670 fn cst_decode(self) -> crate::bindings::LNInvoice {
10672 crate::bindings::LNInvoice {
10673 bolt11: self.bolt11.cst_decode(),
10674 network: self.network.cst_decode(),
10675 payee_pubkey: self.payee_pubkey.cst_decode(),
10676 payment_hash: self.payment_hash.cst_decode(),
10677 description: self.description.cst_decode(),
10678 description_hash: self.description_hash.cst_decode(),
10679 amount_msat: self.amount_msat.cst_decode(),
10680 timestamp: self.timestamp.cst_decode(),
10681 expiry: self.expiry.cst_decode(),
10682 routing_hints: self.routing_hints.cst_decode(),
10683 payment_secret: self.payment_secret.cst_decode(),
10684 min_final_cltv_expiry_delta: self.min_final_cltv_expiry_delta.cst_decode(),
10685 }
10686 }
10687 }
10688 impl CstDecode<crate::bindings::LNOffer> for wire_cst_ln_offer {
10689 fn cst_decode(self) -> crate::bindings::LNOffer {
10691 crate::bindings::LNOffer {
10692 offer: self.offer.cst_decode(),
10693 chains: self.chains.cst_decode(),
10694 min_amount: self.min_amount.cst_decode(),
10695 description: self.description.cst_decode(),
10696 absolute_expiry: self.absolute_expiry.cst_decode(),
10697 issuer: self.issuer.cst_decode(),
10698 signing_pubkey: self.signing_pubkey.cst_decode(),
10699 paths: self.paths.cst_decode(),
10700 }
10701 }
10702 }
10703 impl CstDecode<crate::bindings::LnOfferBlindedPath> for wire_cst_ln_offer_blinded_path {
10704 fn cst_decode(self) -> crate::bindings::LnOfferBlindedPath {
10706 crate::bindings::LnOfferBlindedPath {
10707 blinded_hops: self.blinded_hops.cst_decode(),
10708 }
10709 }
10710 }
10711 impl CstDecode<crate::bindings::duplicates::LnUrlAuthError> for wire_cst_ln_url_auth_error {
10712 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlAuthError {
10714 match self.tag {
10715 0 => {
10716 let ans = unsafe { self.kind.Generic };
10717 crate::bindings::duplicates::LnUrlAuthError::Generic {
10718 err: ans.err.cst_decode(),
10719 }
10720 }
10721 1 => {
10722 let ans = unsafe { self.kind.InvalidUri };
10723 crate::bindings::duplicates::LnUrlAuthError::InvalidUri {
10724 err: ans.err.cst_decode(),
10725 }
10726 }
10727 2 => {
10728 let ans = unsafe { self.kind.ServiceConnectivity };
10729 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
10730 err: ans.err.cst_decode(),
10731 }
10732 }
10733 _ => unreachable!(),
10734 }
10735 }
10736 }
10737 impl CstDecode<crate::bindings::LnUrlAuthRequestData> for wire_cst_ln_url_auth_request_data {
10738 fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10740 crate::bindings::LnUrlAuthRequestData {
10741 k1: self.k1.cst_decode(),
10742 action: self.action.cst_decode(),
10743 domain: self.domain.cst_decode(),
10744 url: self.url.cst_decode(),
10745 }
10746 }
10747 }
10748 impl CstDecode<crate::bindings::duplicates::LnUrlCallbackStatus>
10749 for wire_cst_ln_url_callback_status
10750 {
10751 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
10753 match self.tag {
10754 0 => crate::bindings::duplicates::LnUrlCallbackStatus::Ok,
10755 1 => {
10756 let ans = unsafe { self.kind.ErrorStatus };
10757 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
10758 data: ans.data.cst_decode(),
10759 }
10760 }
10761 _ => unreachable!(),
10762 }
10763 }
10764 }
10765 impl CstDecode<crate::bindings::LnUrlErrorData> for wire_cst_ln_url_error_data {
10766 fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10768 crate::bindings::LnUrlErrorData {
10769 reason: self.reason.cst_decode(),
10770 }
10771 }
10772 }
10773 impl CstDecode<crate::model::LnUrlInfo> for wire_cst_ln_url_info {
10774 fn cst_decode(self) -> crate::model::LnUrlInfo {
10776 crate::model::LnUrlInfo {
10777 ln_address: self.ln_address.cst_decode(),
10778 lnurl_pay_comment: self.lnurl_pay_comment.cst_decode(),
10779 lnurl_pay_domain: self.lnurl_pay_domain.cst_decode(),
10780 lnurl_pay_metadata: self.lnurl_pay_metadata.cst_decode(),
10781 lnurl_pay_success_action: self.lnurl_pay_success_action.cst_decode(),
10782 lnurl_pay_unprocessed_success_action: self
10783 .lnurl_pay_unprocessed_success_action
10784 .cst_decode(),
10785 lnurl_withdraw_endpoint: self.lnurl_withdraw_endpoint.cst_decode(),
10786 }
10787 }
10788 }
10789 impl CstDecode<crate::bindings::duplicates::LnUrlPayError> for wire_cst_ln_url_pay_error {
10790 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlPayError {
10792 match self.tag {
10793 0 => crate::bindings::duplicates::LnUrlPayError::AlreadyPaid,
10794 1 => {
10795 let ans = unsafe { self.kind.Generic };
10796 crate::bindings::duplicates::LnUrlPayError::Generic {
10797 err: ans.err.cst_decode(),
10798 }
10799 }
10800 2 => {
10801 let ans = unsafe { self.kind.InsufficientBalance };
10802 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
10803 err: ans.err.cst_decode(),
10804 }
10805 }
10806 3 => {
10807 let ans = unsafe { self.kind.InvalidAmount };
10808 crate::bindings::duplicates::LnUrlPayError::InvalidAmount {
10809 err: ans.err.cst_decode(),
10810 }
10811 }
10812 4 => {
10813 let ans = unsafe { self.kind.InvalidInvoice };
10814 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice {
10815 err: ans.err.cst_decode(),
10816 }
10817 }
10818 5 => {
10819 let ans = unsafe { self.kind.InvalidNetwork };
10820 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork {
10821 err: ans.err.cst_decode(),
10822 }
10823 }
10824 6 => {
10825 let ans = unsafe { self.kind.InvalidUri };
10826 crate::bindings::duplicates::LnUrlPayError::InvalidUri {
10827 err: ans.err.cst_decode(),
10828 }
10829 }
10830 7 => {
10831 let ans = unsafe { self.kind.InvoiceExpired };
10832 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired {
10833 err: ans.err.cst_decode(),
10834 }
10835 }
10836 8 => {
10837 let ans = unsafe { self.kind.PaymentFailed };
10838 crate::bindings::duplicates::LnUrlPayError::PaymentFailed {
10839 err: ans.err.cst_decode(),
10840 }
10841 }
10842 9 => {
10843 let ans = unsafe { self.kind.PaymentTimeout };
10844 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout {
10845 err: ans.err.cst_decode(),
10846 }
10847 }
10848 10 => {
10849 let ans = unsafe { self.kind.RouteNotFound };
10850 crate::bindings::duplicates::LnUrlPayError::RouteNotFound {
10851 err: ans.err.cst_decode(),
10852 }
10853 }
10854 11 => {
10855 let ans = unsafe { self.kind.RouteTooExpensive };
10856 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
10857 err: ans.err.cst_decode(),
10858 }
10859 }
10860 12 => {
10861 let ans = unsafe { self.kind.ServiceConnectivity };
10862 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
10863 err: ans.err.cst_decode(),
10864 }
10865 }
10866 _ => unreachable!(),
10867 }
10868 }
10869 }
10870 impl CstDecode<crate::bindings::LnUrlPayErrorData> for wire_cst_ln_url_pay_error_data {
10871 fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10873 crate::bindings::LnUrlPayErrorData {
10874 payment_hash: self.payment_hash.cst_decode(),
10875 reason: self.reason.cst_decode(),
10876 }
10877 }
10878 }
10879 impl CstDecode<crate::model::LnUrlPayRequest> for wire_cst_ln_url_pay_request {
10880 fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10882 crate::model::LnUrlPayRequest {
10883 prepare_response: self.prepare_response.cst_decode(),
10884 }
10885 }
10886 }
10887 impl CstDecode<crate::bindings::LnUrlPayRequestData> for wire_cst_ln_url_pay_request_data {
10888 fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10890 crate::bindings::LnUrlPayRequestData {
10891 callback: self.callback.cst_decode(),
10892 min_sendable: self.min_sendable.cst_decode(),
10893 max_sendable: self.max_sendable.cst_decode(),
10894 metadata_str: self.metadata_str.cst_decode(),
10895 comment_allowed: self.comment_allowed.cst_decode(),
10896 domain: self.domain.cst_decode(),
10897 allows_nostr: self.allows_nostr.cst_decode(),
10898 nostr_pubkey: self.nostr_pubkey.cst_decode(),
10899 ln_address: self.ln_address.cst_decode(),
10900 }
10901 }
10902 }
10903 impl CstDecode<crate::model::LnUrlPayResult> for wire_cst_ln_url_pay_result {
10904 fn cst_decode(self) -> crate::model::LnUrlPayResult {
10906 match self.tag {
10907 0 => {
10908 let ans = unsafe { self.kind.EndpointSuccess };
10909 crate::model::LnUrlPayResult::EndpointSuccess {
10910 data: ans.data.cst_decode(),
10911 }
10912 }
10913 1 => {
10914 let ans = unsafe { self.kind.EndpointError };
10915 crate::model::LnUrlPayResult::EndpointError {
10916 data: ans.data.cst_decode(),
10917 }
10918 }
10919 2 => {
10920 let ans = unsafe { self.kind.PayError };
10921 crate::model::LnUrlPayResult::PayError {
10922 data: ans.data.cst_decode(),
10923 }
10924 }
10925 _ => unreachable!(),
10926 }
10927 }
10928 }
10929 impl CstDecode<crate::model::LnUrlPaySuccessData> for wire_cst_ln_url_pay_success_data {
10930 fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10932 crate::model::LnUrlPaySuccessData {
10933 payment: self.payment.cst_decode(),
10934 success_action: self.success_action.cst_decode(),
10935 }
10936 }
10937 }
10938 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawError> for wire_cst_ln_url_withdraw_error {
10939 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
10941 match self.tag {
10942 0 => {
10943 let ans = unsafe { self.kind.Generic };
10944 crate::bindings::duplicates::LnUrlWithdrawError::Generic {
10945 err: ans.err.cst_decode(),
10946 }
10947 }
10948 1 => {
10949 let ans = unsafe { self.kind.InvalidAmount };
10950 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
10951 err: ans.err.cst_decode(),
10952 }
10953 }
10954 2 => {
10955 let ans = unsafe { self.kind.InvalidInvoice };
10956 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
10957 err: ans.err.cst_decode(),
10958 }
10959 }
10960 3 => {
10961 let ans = unsafe { self.kind.InvalidUri };
10962 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
10963 err: ans.err.cst_decode(),
10964 }
10965 }
10966 4 => {
10967 let ans = unsafe { self.kind.InvoiceNoRoutingHints };
10968 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
10969 err: ans.err.cst_decode(),
10970 }
10971 }
10972 5 => {
10973 let ans = unsafe { self.kind.ServiceConnectivity };
10974 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
10975 err: ans.err.cst_decode(),
10976 }
10977 }
10978 _ => unreachable!(),
10979 }
10980 }
10981 }
10982 impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for wire_cst_ln_url_withdraw_request {
10983 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
10985 crate::bindings::LnUrlWithdrawRequest {
10986 data: self.data.cst_decode(),
10987 amount_msat: self.amount_msat.cst_decode(),
10988 description: self.description.cst_decode(),
10989 }
10990 }
10991 }
10992 impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
10993 for wire_cst_ln_url_withdraw_request_data
10994 {
10995 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
10997 crate::bindings::LnUrlWithdrawRequestData {
10998 callback: self.callback.cst_decode(),
10999 k1: self.k1.cst_decode(),
11000 default_description: self.default_description.cst_decode(),
11001 min_withdrawable: self.min_withdrawable.cst_decode(),
11002 max_withdrawable: self.max_withdrawable.cst_decode(),
11003 }
11004 }
11005 }
11006 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawResult>
11007 for wire_cst_ln_url_withdraw_result
11008 {
11009 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
11011 match self.tag {
11012 0 => {
11013 let ans = unsafe { self.kind.Ok };
11014 crate::bindings::duplicates::LnUrlWithdrawResult::Ok {
11015 data: ans.data.cst_decode(),
11016 }
11017 }
11018 1 => {
11019 let ans = unsafe { self.kind.Timeout };
11020 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
11021 data: ans.data.cst_decode(),
11022 }
11023 }
11024 2 => {
11025 let ans = unsafe { self.kind.ErrorStatus };
11026 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
11027 data: ans.data.cst_decode(),
11028 }
11029 }
11030 _ => unreachable!(),
11031 }
11032 }
11033 }
11034 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
11035 for wire_cst_ln_url_withdraw_success_data
11036 {
11037 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11039 crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11040 invoice: self.invoice.cst_decode(),
11041 }
11042 }
11043 }
11044 impl CstDecode<crate::bindings::LocaleOverrides> for wire_cst_locale_overrides {
11045 fn cst_decode(self) -> crate::bindings::LocaleOverrides {
11047 crate::bindings::LocaleOverrides {
11048 locale: self.locale.cst_decode(),
11049 spacing: self.spacing.cst_decode(),
11050 symbol: self.symbol.cst_decode(),
11051 }
11052 }
11053 }
11054 impl CstDecode<crate::bindings::LocalizedName> for wire_cst_localized_name {
11055 fn cst_decode(self) -> crate::bindings::LocalizedName {
11057 crate::bindings::LocalizedName {
11058 locale: self.locale.cst_decode(),
11059 name: self.name.cst_decode(),
11060 }
11061 }
11062 }
11063 impl CstDecode<crate::model::LogEntry> for wire_cst_log_entry {
11064 fn cst_decode(self) -> crate::model::LogEntry {
11066 crate::model::LogEntry {
11067 line: self.line.cst_decode(),
11068 level: self.level.cst_decode(),
11069 }
11070 }
11071 }
11072 impl CstDecode<crate::bindings::MessageSuccessActionData> for wire_cst_message_success_action_data {
11073 fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
11075 crate::bindings::MessageSuccessActionData {
11076 message: self.message.cst_decode(),
11077 }
11078 }
11079 }
11080 impl CstDecode<crate::model::OnchainPaymentLimitsResponse>
11081 for wire_cst_onchain_payment_limits_response
11082 {
11083 fn cst_decode(self) -> crate::model::OnchainPaymentLimitsResponse {
11085 crate::model::OnchainPaymentLimitsResponse {
11086 send: self.send.cst_decode(),
11087 receive: self.receive.cst_decode(),
11088 }
11089 }
11090 }
11091 impl CstDecode<crate::model::PayAmount> for wire_cst_pay_amount {
11092 fn cst_decode(self) -> crate::model::PayAmount {
11094 match self.tag {
11095 0 => {
11096 let ans = unsafe { self.kind.Bitcoin };
11097 crate::model::PayAmount::Bitcoin {
11098 receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11099 }
11100 }
11101 1 => {
11102 let ans = unsafe { self.kind.Asset };
11103 crate::model::PayAmount::Asset {
11104 asset_id: ans.asset_id.cst_decode(),
11105 receiver_amount: ans.receiver_amount.cst_decode(),
11106 estimate_asset_fees: ans.estimate_asset_fees.cst_decode(),
11107 }
11108 }
11109 2 => crate::model::PayAmount::Drain,
11110 _ => unreachable!(),
11111 }
11112 }
11113 }
11114 impl CstDecode<crate::model::PayOnchainRequest> for wire_cst_pay_onchain_request {
11115 fn cst_decode(self) -> crate::model::PayOnchainRequest {
11117 crate::model::PayOnchainRequest {
11118 address: self.address.cst_decode(),
11119 prepare_response: self.prepare_response.cst_decode(),
11120 }
11121 }
11122 }
11123 impl CstDecode<crate::model::Payment> for wire_cst_payment {
11124 fn cst_decode(self) -> crate::model::Payment {
11126 crate::model::Payment {
11127 destination: self.destination.cst_decode(),
11128 tx_id: self.tx_id.cst_decode(),
11129 unblinding_data: self.unblinding_data.cst_decode(),
11130 timestamp: self.timestamp.cst_decode(),
11131 amount_sat: self.amount_sat.cst_decode(),
11132 fees_sat: self.fees_sat.cst_decode(),
11133 swapper_fees_sat: self.swapper_fees_sat.cst_decode(),
11134 payment_type: self.payment_type.cst_decode(),
11135 status: self.status.cst_decode(),
11136 details: self.details.cst_decode(),
11137 }
11138 }
11139 }
11140 impl CstDecode<crate::model::PaymentDetails> for wire_cst_payment_details {
11141 fn cst_decode(self) -> crate::model::PaymentDetails {
11143 match self.tag {
11144 0 => {
11145 let ans = unsafe { self.kind.Lightning };
11146 crate::model::PaymentDetails::Lightning {
11147 swap_id: ans.swap_id.cst_decode(),
11148 description: ans.description.cst_decode(),
11149 liquid_expiration_blockheight: ans
11150 .liquid_expiration_blockheight
11151 .cst_decode(),
11152 preimage: ans.preimage.cst_decode(),
11153 invoice: ans.invoice.cst_decode(),
11154 bolt12_offer: ans.bolt12_offer.cst_decode(),
11155 payment_hash: ans.payment_hash.cst_decode(),
11156 destination_pubkey: ans.destination_pubkey.cst_decode(),
11157 lnurl_info: ans.lnurl_info.cst_decode(),
11158 bip353_address: ans.bip353_address.cst_decode(),
11159 claim_tx_id: ans.claim_tx_id.cst_decode(),
11160 refund_tx_id: ans.refund_tx_id.cst_decode(),
11161 refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11162 }
11163 }
11164 1 => {
11165 let ans = unsafe { self.kind.Liquid };
11166 crate::model::PaymentDetails::Liquid {
11167 destination: ans.destination.cst_decode(),
11168 description: ans.description.cst_decode(),
11169 asset_id: ans.asset_id.cst_decode(),
11170 asset_info: ans.asset_info.cst_decode(),
11171 lnurl_info: ans.lnurl_info.cst_decode(),
11172 bip353_address: ans.bip353_address.cst_decode(),
11173 }
11174 }
11175 2 => {
11176 let ans = unsafe { self.kind.Bitcoin };
11177 crate::model::PaymentDetails::Bitcoin {
11178 swap_id: ans.swap_id.cst_decode(),
11179 description: ans.description.cst_decode(),
11180 auto_accepted_fees: ans.auto_accepted_fees.cst_decode(),
11181 liquid_expiration_blockheight: ans
11182 .liquid_expiration_blockheight
11183 .cst_decode(),
11184 bitcoin_expiration_blockheight: ans
11185 .bitcoin_expiration_blockheight
11186 .cst_decode(),
11187 claim_tx_id: ans.claim_tx_id.cst_decode(),
11188 refund_tx_id: ans.refund_tx_id.cst_decode(),
11189 refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11190 }
11191 }
11192 _ => unreachable!(),
11193 }
11194 }
11195 }
11196 impl CstDecode<crate::error::PaymentError> for wire_cst_payment_error {
11197 fn cst_decode(self) -> crate::error::PaymentError {
11199 match self.tag {
11200 0 => crate::error::PaymentError::AlreadyClaimed,
11201 1 => crate::error::PaymentError::AlreadyPaid,
11202 2 => crate::error::PaymentError::PaymentInProgress,
11203 3 => {
11204 let ans = unsafe { self.kind.AmountOutOfRange };
11205 crate::error::PaymentError::AmountOutOfRange {
11206 min: ans.min.cst_decode(),
11207 max: ans.max.cst_decode(),
11208 }
11209 }
11210 4 => {
11211 let ans = unsafe { self.kind.AmountMissing };
11212 crate::error::PaymentError::AmountMissing {
11213 err: ans.err.cst_decode(),
11214 }
11215 }
11216 5 => {
11217 let ans = unsafe { self.kind.AssetError };
11218 crate::error::PaymentError::AssetError {
11219 err: ans.err.cst_decode(),
11220 }
11221 }
11222 6 => {
11223 let ans = unsafe { self.kind.InvalidNetwork };
11224 crate::error::PaymentError::InvalidNetwork {
11225 err: ans.err.cst_decode(),
11226 }
11227 }
11228 7 => {
11229 let ans = unsafe { self.kind.Generic };
11230 crate::error::PaymentError::Generic {
11231 err: ans.err.cst_decode(),
11232 }
11233 }
11234 8 => crate::error::PaymentError::InvalidOrExpiredFees,
11235 9 => crate::error::PaymentError::InsufficientFunds,
11236 10 => {
11237 let ans = unsafe { self.kind.InvalidDescription };
11238 crate::error::PaymentError::InvalidDescription {
11239 err: ans.err.cst_decode(),
11240 }
11241 }
11242 11 => {
11243 let ans = unsafe { self.kind.InvalidInvoice };
11244 crate::error::PaymentError::InvalidInvoice {
11245 err: ans.err.cst_decode(),
11246 }
11247 }
11248 12 => crate::error::PaymentError::InvalidPreimage,
11249 13 => crate::error::PaymentError::PairsNotFound,
11250 14 => crate::error::PaymentError::PaymentTimeout,
11251 15 => crate::error::PaymentError::PersistError,
11252 16 => {
11253 let ans = unsafe { self.kind.ReceiveError };
11254 crate::error::PaymentError::ReceiveError {
11255 err: ans.err.cst_decode(),
11256 }
11257 }
11258 17 => {
11259 let ans = unsafe { self.kind.Refunded };
11260 crate::error::PaymentError::Refunded {
11261 err: ans.err.cst_decode(),
11262 refund_tx_id: ans.refund_tx_id.cst_decode(),
11263 }
11264 }
11265 18 => crate::error::PaymentError::SelfTransferNotSupported,
11266 19 => {
11267 let ans = unsafe { self.kind.SendError };
11268 crate::error::PaymentError::SendError {
11269 err: ans.err.cst_decode(),
11270 }
11271 }
11272 20 => {
11273 let ans = unsafe { self.kind.SignerError };
11274 crate::error::PaymentError::SignerError {
11275 err: ans.err.cst_decode(),
11276 }
11277 }
11278 _ => unreachable!(),
11279 }
11280 }
11281 }
11282 impl CstDecode<crate::model::PrepareBuyBitcoinRequest> for wire_cst_prepare_buy_bitcoin_request {
11283 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
11285 crate::model::PrepareBuyBitcoinRequest {
11286 provider: self.provider.cst_decode(),
11287 amount_sat: self.amount_sat.cst_decode(),
11288 }
11289 }
11290 }
11291 impl CstDecode<crate::model::PrepareBuyBitcoinResponse> for wire_cst_prepare_buy_bitcoin_response {
11292 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinResponse {
11294 crate::model::PrepareBuyBitcoinResponse {
11295 provider: self.provider.cst_decode(),
11296 amount_sat: self.amount_sat.cst_decode(),
11297 fees_sat: self.fees_sat.cst_decode(),
11298 }
11299 }
11300 }
11301 impl CstDecode<crate::model::PrepareLnUrlPayRequest> for wire_cst_prepare_ln_url_pay_request {
11302 fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
11304 crate::model::PrepareLnUrlPayRequest {
11305 data: self.data.cst_decode(),
11306 amount: self.amount.cst_decode(),
11307 bip353_address: self.bip353_address.cst_decode(),
11308 comment: self.comment.cst_decode(),
11309 validate_success_action_url: self.validate_success_action_url.cst_decode(),
11310 }
11311 }
11312 }
11313 impl CstDecode<crate::model::PrepareLnUrlPayResponse> for wire_cst_prepare_ln_url_pay_response {
11314 fn cst_decode(self) -> crate::model::PrepareLnUrlPayResponse {
11316 crate::model::PrepareLnUrlPayResponse {
11317 destination: self.destination.cst_decode(),
11318 fees_sat: self.fees_sat.cst_decode(),
11319 data: self.data.cst_decode(),
11320 comment: self.comment.cst_decode(),
11321 success_action: self.success_action.cst_decode(),
11322 }
11323 }
11324 }
11325 impl CstDecode<crate::model::PreparePayOnchainRequest> for wire_cst_prepare_pay_onchain_request {
11326 fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
11328 crate::model::PreparePayOnchainRequest {
11329 amount: self.amount.cst_decode(),
11330 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11331 }
11332 }
11333 }
11334 impl CstDecode<crate::model::PreparePayOnchainResponse> for wire_cst_prepare_pay_onchain_response {
11335 fn cst_decode(self) -> crate::model::PreparePayOnchainResponse {
11337 crate::model::PreparePayOnchainResponse {
11338 receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
11339 claim_fees_sat: self.claim_fees_sat.cst_decode(),
11340 total_fees_sat: self.total_fees_sat.cst_decode(),
11341 }
11342 }
11343 }
11344 impl CstDecode<crate::model::PrepareReceiveRequest> for wire_cst_prepare_receive_request {
11345 fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
11347 crate::model::PrepareReceiveRequest {
11348 payment_method: self.payment_method.cst_decode(),
11349 amount: self.amount.cst_decode(),
11350 }
11351 }
11352 }
11353 impl CstDecode<crate::model::PrepareReceiveResponse> for wire_cst_prepare_receive_response {
11354 fn cst_decode(self) -> crate::model::PrepareReceiveResponse {
11356 crate::model::PrepareReceiveResponse {
11357 payment_method: self.payment_method.cst_decode(),
11358 fees_sat: self.fees_sat.cst_decode(),
11359 amount: self.amount.cst_decode(),
11360 min_payer_amount_sat: self.min_payer_amount_sat.cst_decode(),
11361 max_payer_amount_sat: self.max_payer_amount_sat.cst_decode(),
11362 swapper_feerate: self.swapper_feerate.cst_decode(),
11363 }
11364 }
11365 }
11366 impl CstDecode<crate::model::PrepareRefundRequest> for wire_cst_prepare_refund_request {
11367 fn cst_decode(self) -> crate::model::PrepareRefundRequest {
11369 crate::model::PrepareRefundRequest {
11370 swap_address: self.swap_address.cst_decode(),
11371 refund_address: self.refund_address.cst_decode(),
11372 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11373 }
11374 }
11375 }
11376 impl CstDecode<crate::model::PrepareRefundResponse> for wire_cst_prepare_refund_response {
11377 fn cst_decode(self) -> crate::model::PrepareRefundResponse {
11379 crate::model::PrepareRefundResponse {
11380 tx_vsize: self.tx_vsize.cst_decode(),
11381 tx_fee_sat: self.tx_fee_sat.cst_decode(),
11382 last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11383 }
11384 }
11385 }
11386 impl CstDecode<crate::model::PrepareSendRequest> for wire_cst_prepare_send_request {
11387 fn cst_decode(self) -> crate::model::PrepareSendRequest {
11389 crate::model::PrepareSendRequest {
11390 destination: self.destination.cst_decode(),
11391 amount: self.amount.cst_decode(),
11392 }
11393 }
11394 }
11395 impl CstDecode<crate::model::PrepareSendResponse> for wire_cst_prepare_send_response {
11396 fn cst_decode(self) -> crate::model::PrepareSendResponse {
11398 crate::model::PrepareSendResponse {
11399 destination: self.destination.cst_decode(),
11400 fees_sat: self.fees_sat.cst_decode(),
11401 estimated_asset_fees: self.estimated_asset_fees.cst_decode(),
11402 }
11403 }
11404 }
11405 impl CstDecode<crate::bindings::Rate> for wire_cst_rate {
11406 fn cst_decode(self) -> crate::bindings::Rate {
11408 crate::bindings::Rate {
11409 coin: self.coin.cst_decode(),
11410 value: self.value.cst_decode(),
11411 }
11412 }
11413 }
11414 impl CstDecode<crate::model::ReceiveAmount> for wire_cst_receive_amount {
11415 fn cst_decode(self) -> crate::model::ReceiveAmount {
11417 match self.tag {
11418 0 => {
11419 let ans = unsafe { self.kind.Bitcoin };
11420 crate::model::ReceiveAmount::Bitcoin {
11421 payer_amount_sat: ans.payer_amount_sat.cst_decode(),
11422 }
11423 }
11424 1 => {
11425 let ans = unsafe { self.kind.Asset };
11426 crate::model::ReceiveAmount::Asset {
11427 asset_id: ans.asset_id.cst_decode(),
11428 payer_amount: ans.payer_amount.cst_decode(),
11429 }
11430 }
11431 _ => unreachable!(),
11432 }
11433 }
11434 }
11435 impl CstDecode<crate::model::ReceivePaymentRequest> for wire_cst_receive_payment_request {
11436 fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
11438 crate::model::ReceivePaymentRequest {
11439 prepare_response: self.prepare_response.cst_decode(),
11440 description: self.description.cst_decode(),
11441 use_description_hash: self.use_description_hash.cst_decode(),
11442 }
11443 }
11444 }
11445 impl CstDecode<crate::model::ReceivePaymentResponse> for wire_cst_receive_payment_response {
11446 fn cst_decode(self) -> crate::model::ReceivePaymentResponse {
11448 crate::model::ReceivePaymentResponse {
11449 destination: self.destination.cst_decode(),
11450 }
11451 }
11452 }
11453 impl CstDecode<crate::model::RecommendedFees> for wire_cst_recommended_fees {
11454 fn cst_decode(self) -> crate::model::RecommendedFees {
11456 crate::model::RecommendedFees {
11457 fastest_fee: self.fastest_fee.cst_decode(),
11458 half_hour_fee: self.half_hour_fee.cst_decode(),
11459 hour_fee: self.hour_fee.cst_decode(),
11460 economy_fee: self.economy_fee.cst_decode(),
11461 minimum_fee: self.minimum_fee.cst_decode(),
11462 }
11463 }
11464 }
11465 impl CstDecode<crate::model::RefundRequest> for wire_cst_refund_request {
11466 fn cst_decode(self) -> crate::model::RefundRequest {
11468 crate::model::RefundRequest {
11469 swap_address: self.swap_address.cst_decode(),
11470 refund_address: self.refund_address.cst_decode(),
11471 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11472 }
11473 }
11474 }
11475 impl CstDecode<crate::model::RefundResponse> for wire_cst_refund_response {
11476 fn cst_decode(self) -> crate::model::RefundResponse {
11478 crate::model::RefundResponse {
11479 refund_tx_id: self.refund_tx_id.cst_decode(),
11480 }
11481 }
11482 }
11483 impl CstDecode<crate::model::RefundableSwap> for wire_cst_refundable_swap {
11484 fn cst_decode(self) -> crate::model::RefundableSwap {
11486 crate::model::RefundableSwap {
11487 swap_address: self.swap_address.cst_decode(),
11488 timestamp: self.timestamp.cst_decode(),
11489 amount_sat: self.amount_sat.cst_decode(),
11490 last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11491 }
11492 }
11493 }
11494 impl CstDecode<crate::model::RestoreRequest> for wire_cst_restore_request {
11495 fn cst_decode(self) -> crate::model::RestoreRequest {
11497 crate::model::RestoreRequest {
11498 backup_path: self.backup_path.cst_decode(),
11499 }
11500 }
11501 }
11502 impl CstDecode<crate::bindings::RouteHint> for wire_cst_route_hint {
11503 fn cst_decode(self) -> crate::bindings::RouteHint {
11505 crate::bindings::RouteHint {
11506 hops: self.hops.cst_decode(),
11507 }
11508 }
11509 }
11510 impl CstDecode<crate::bindings::RouteHintHop> for wire_cst_route_hint_hop {
11511 fn cst_decode(self) -> crate::bindings::RouteHintHop {
11513 crate::bindings::RouteHintHop {
11514 src_node_id: self.src_node_id.cst_decode(),
11515 short_channel_id: self.short_channel_id.cst_decode(),
11516 fees_base_msat: self.fees_base_msat.cst_decode(),
11517 fees_proportional_millionths: self.fees_proportional_millionths.cst_decode(),
11518 cltv_expiry_delta: self.cltv_expiry_delta.cst_decode(),
11519 htlc_minimum_msat: self.htlc_minimum_msat.cst_decode(),
11520 htlc_maximum_msat: self.htlc_maximum_msat.cst_decode(),
11521 }
11522 }
11523 }
11524 impl CstDecode<crate::error::SdkError> for wire_cst_sdk_error {
11525 fn cst_decode(self) -> crate::error::SdkError {
11527 match self.tag {
11528 0 => crate::error::SdkError::AlreadyStarted,
11529 1 => {
11530 let ans = unsafe { self.kind.Generic };
11531 crate::error::SdkError::Generic {
11532 err: ans.err.cst_decode(),
11533 }
11534 }
11535 2 => crate::error::SdkError::NotStarted,
11536 3 => {
11537 let ans = unsafe { self.kind.ServiceConnectivity };
11538 crate::error::SdkError::ServiceConnectivity {
11539 err: ans.err.cst_decode(),
11540 }
11541 }
11542 _ => unreachable!(),
11543 }
11544 }
11545 }
11546 impl CstDecode<crate::model::SdkEvent> for wire_cst_sdk_event {
11547 fn cst_decode(self) -> crate::model::SdkEvent {
11549 match self.tag {
11550 0 => {
11551 let ans = unsafe { self.kind.PaymentFailed };
11552 crate::model::SdkEvent::PaymentFailed {
11553 details: ans.details.cst_decode(),
11554 }
11555 }
11556 1 => {
11557 let ans = unsafe { self.kind.PaymentPending };
11558 crate::model::SdkEvent::PaymentPending {
11559 details: ans.details.cst_decode(),
11560 }
11561 }
11562 2 => {
11563 let ans = unsafe { self.kind.PaymentRefundable };
11564 crate::model::SdkEvent::PaymentRefundable {
11565 details: ans.details.cst_decode(),
11566 }
11567 }
11568 3 => {
11569 let ans = unsafe { self.kind.PaymentRefunded };
11570 crate::model::SdkEvent::PaymentRefunded {
11571 details: ans.details.cst_decode(),
11572 }
11573 }
11574 4 => {
11575 let ans = unsafe { self.kind.PaymentRefundPending };
11576 crate::model::SdkEvent::PaymentRefundPending {
11577 details: ans.details.cst_decode(),
11578 }
11579 }
11580 5 => {
11581 let ans = unsafe { self.kind.PaymentSucceeded };
11582 crate::model::SdkEvent::PaymentSucceeded {
11583 details: ans.details.cst_decode(),
11584 }
11585 }
11586 6 => {
11587 let ans = unsafe { self.kind.PaymentWaitingConfirmation };
11588 crate::model::SdkEvent::PaymentWaitingConfirmation {
11589 details: ans.details.cst_decode(),
11590 }
11591 }
11592 7 => {
11593 let ans = unsafe { self.kind.PaymentWaitingFeeAcceptance };
11594 crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
11595 details: ans.details.cst_decode(),
11596 }
11597 }
11598 8 => crate::model::SdkEvent::Synced,
11599 9 => {
11600 let ans = unsafe { self.kind.DataSynced };
11601 crate::model::SdkEvent::DataSynced {
11602 did_pull_new_records: ans.did_pull_new_records.cst_decode(),
11603 }
11604 }
11605 _ => unreachable!(),
11606 }
11607 }
11608 }
11609 impl CstDecode<crate::model::SendDestination> for wire_cst_send_destination {
11610 fn cst_decode(self) -> crate::model::SendDestination {
11612 match self.tag {
11613 0 => {
11614 let ans = unsafe { self.kind.LiquidAddress };
11615 crate::model::SendDestination::LiquidAddress {
11616 address_data: ans.address_data.cst_decode(),
11617 bip353_address: ans.bip353_address.cst_decode(),
11618 }
11619 }
11620 1 => {
11621 let ans = unsafe { self.kind.Bolt11 };
11622 crate::model::SendDestination::Bolt11 {
11623 invoice: ans.invoice.cst_decode(),
11624 bip353_address: ans.bip353_address.cst_decode(),
11625 }
11626 }
11627 2 => {
11628 let ans = unsafe { self.kind.Bolt12 };
11629 crate::model::SendDestination::Bolt12 {
11630 offer: ans.offer.cst_decode(),
11631 receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11632 bip353_address: ans.bip353_address.cst_decode(),
11633 }
11634 }
11635 _ => unreachable!(),
11636 }
11637 }
11638 }
11639 impl CstDecode<crate::model::SendPaymentRequest> for wire_cst_send_payment_request {
11640 fn cst_decode(self) -> crate::model::SendPaymentRequest {
11642 crate::model::SendPaymentRequest {
11643 prepare_response: self.prepare_response.cst_decode(),
11644 use_asset_fees: self.use_asset_fees.cst_decode(),
11645 }
11646 }
11647 }
11648 impl CstDecode<crate::model::SendPaymentResponse> for wire_cst_send_payment_response {
11649 fn cst_decode(self) -> crate::model::SendPaymentResponse {
11651 crate::model::SendPaymentResponse {
11652 payment: self.payment.cst_decode(),
11653 }
11654 }
11655 }
11656 impl CstDecode<crate::model::SignMessageRequest> for wire_cst_sign_message_request {
11657 fn cst_decode(self) -> crate::model::SignMessageRequest {
11659 crate::model::SignMessageRequest {
11660 message: self.message.cst_decode(),
11661 }
11662 }
11663 }
11664 impl CstDecode<crate::model::SignMessageResponse> for wire_cst_sign_message_response {
11665 fn cst_decode(self) -> crate::model::SignMessageResponse {
11667 crate::model::SignMessageResponse {
11668 signature: self.signature.cst_decode(),
11669 }
11670 }
11671 }
11672 impl CstDecode<crate::bindings::SuccessAction> for wire_cst_success_action {
11673 fn cst_decode(self) -> crate::bindings::SuccessAction {
11675 match self.tag {
11676 0 => {
11677 let ans = unsafe { self.kind.Aes };
11678 crate::bindings::SuccessAction::Aes {
11679 data: ans.data.cst_decode(),
11680 }
11681 }
11682 1 => {
11683 let ans = unsafe { self.kind.Message };
11684 crate::bindings::SuccessAction::Message {
11685 data: ans.data.cst_decode(),
11686 }
11687 }
11688 2 => {
11689 let ans = unsafe { self.kind.Url };
11690 crate::bindings::SuccessAction::Url {
11691 data: ans.data.cst_decode(),
11692 }
11693 }
11694 _ => unreachable!(),
11695 }
11696 }
11697 }
11698 impl CstDecode<crate::bindings::SuccessActionProcessed> for wire_cst_success_action_processed {
11699 fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
11701 match self.tag {
11702 0 => {
11703 let ans = unsafe { self.kind.Aes };
11704 crate::bindings::SuccessActionProcessed::Aes {
11705 result: ans.result.cst_decode(),
11706 }
11707 }
11708 1 => {
11709 let ans = unsafe { self.kind.Message };
11710 crate::bindings::SuccessActionProcessed::Message {
11711 data: ans.data.cst_decode(),
11712 }
11713 }
11714 2 => {
11715 let ans = unsafe { self.kind.Url };
11716 crate::bindings::SuccessActionProcessed::Url {
11717 data: ans.data.cst_decode(),
11718 }
11719 }
11720 _ => unreachable!(),
11721 }
11722 }
11723 }
11724 impl CstDecode<crate::bindings::Symbol> for wire_cst_symbol {
11725 fn cst_decode(self) -> crate::bindings::Symbol {
11727 crate::bindings::Symbol {
11728 grapheme: self.grapheme.cst_decode(),
11729 template: self.template.cst_decode(),
11730 rtl: self.rtl.cst_decode(),
11731 position: self.position.cst_decode(),
11732 }
11733 }
11734 }
11735 impl CstDecode<crate::bindings::UrlSuccessActionData> for wire_cst_url_success_action_data {
11736 fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
11738 crate::bindings::UrlSuccessActionData {
11739 description: self.description.cst_decode(),
11740 url: self.url.cst_decode(),
11741 matches_callback_domain: self.matches_callback_domain.cst_decode(),
11742 }
11743 }
11744 }
11745 impl CstDecode<crate::model::WalletInfo> for wire_cst_wallet_info {
11746 fn cst_decode(self) -> crate::model::WalletInfo {
11748 crate::model::WalletInfo {
11749 balance_sat: self.balance_sat.cst_decode(),
11750 pending_send_sat: self.pending_send_sat.cst_decode(),
11751 pending_receive_sat: self.pending_receive_sat.cst_decode(),
11752 fingerprint: self.fingerprint.cst_decode(),
11753 pubkey: self.pubkey.cst_decode(),
11754 asset_balances: self.asset_balances.cst_decode(),
11755 }
11756 }
11757 }
11758 impl NewWithNullPtr for wire_cst_accept_payment_proposed_fees_request {
11759 fn new_with_null_ptr() -> Self {
11760 Self {
11761 response: Default::default(),
11762 }
11763 }
11764 }
11765 impl Default for wire_cst_accept_payment_proposed_fees_request {
11766 fn default() -> Self {
11767 Self::new_with_null_ptr()
11768 }
11769 }
11770 impl NewWithNullPtr for wire_cst_aes_success_action_data {
11771 fn new_with_null_ptr() -> Self {
11772 Self {
11773 description: core::ptr::null_mut(),
11774 ciphertext: core::ptr::null_mut(),
11775 iv: core::ptr::null_mut(),
11776 }
11777 }
11778 }
11779 impl Default for wire_cst_aes_success_action_data {
11780 fn default() -> Self {
11781 Self::new_with_null_ptr()
11782 }
11783 }
11784 impl NewWithNullPtr for wire_cst_aes_success_action_data_decrypted {
11785 fn new_with_null_ptr() -> Self {
11786 Self {
11787 description: core::ptr::null_mut(),
11788 plaintext: core::ptr::null_mut(),
11789 }
11790 }
11791 }
11792 impl Default for wire_cst_aes_success_action_data_decrypted {
11793 fn default() -> Self {
11794 Self::new_with_null_ptr()
11795 }
11796 }
11797 impl NewWithNullPtr for wire_cst_aes_success_action_data_result {
11798 fn new_with_null_ptr() -> Self {
11799 Self {
11800 tag: -1,
11801 kind: AesSuccessActionDataResultKind { nil__: () },
11802 }
11803 }
11804 }
11805 impl Default for wire_cst_aes_success_action_data_result {
11806 fn default() -> Self {
11807 Self::new_with_null_ptr()
11808 }
11809 }
11810 impl NewWithNullPtr for wire_cst_amount {
11811 fn new_with_null_ptr() -> Self {
11812 Self {
11813 tag: -1,
11814 kind: AmountKind { nil__: () },
11815 }
11816 }
11817 }
11818 impl Default for wire_cst_amount {
11819 fn default() -> Self {
11820 Self::new_with_null_ptr()
11821 }
11822 }
11823 impl NewWithNullPtr for wire_cst_asset_balance {
11824 fn new_with_null_ptr() -> Self {
11825 Self {
11826 asset_id: core::ptr::null_mut(),
11827 balance_sat: Default::default(),
11828 name: core::ptr::null_mut(),
11829 ticker: core::ptr::null_mut(),
11830 balance: core::ptr::null_mut(),
11831 }
11832 }
11833 }
11834 impl Default for wire_cst_asset_balance {
11835 fn default() -> Self {
11836 Self::new_with_null_ptr()
11837 }
11838 }
11839 impl NewWithNullPtr for wire_cst_asset_info {
11840 fn new_with_null_ptr() -> Self {
11841 Self {
11842 name: core::ptr::null_mut(),
11843 ticker: core::ptr::null_mut(),
11844 amount: Default::default(),
11845 fees: core::ptr::null_mut(),
11846 }
11847 }
11848 }
11849 impl Default for wire_cst_asset_info {
11850 fn default() -> Self {
11851 Self::new_with_null_ptr()
11852 }
11853 }
11854 impl NewWithNullPtr for wire_cst_asset_metadata {
11855 fn new_with_null_ptr() -> Self {
11856 Self {
11857 asset_id: core::ptr::null_mut(),
11858 name: core::ptr::null_mut(),
11859 ticker: core::ptr::null_mut(),
11860 precision: Default::default(),
11861 fiat_id: core::ptr::null_mut(),
11862 }
11863 }
11864 }
11865 impl Default for wire_cst_asset_metadata {
11866 fn default() -> Self {
11867 Self::new_with_null_ptr()
11868 }
11869 }
11870 impl NewWithNullPtr for wire_cst_backup_request {
11871 fn new_with_null_ptr() -> Self {
11872 Self {
11873 backup_path: core::ptr::null_mut(),
11874 }
11875 }
11876 }
11877 impl Default for wire_cst_backup_request {
11878 fn default() -> Self {
11879 Self::new_with_null_ptr()
11880 }
11881 }
11882 impl NewWithNullPtr for wire_cst_binding_event_listener {
11883 fn new_with_null_ptr() -> Self {
11884 Self {
11885 stream: core::ptr::null_mut(),
11886 }
11887 }
11888 }
11889 impl Default for wire_cst_binding_event_listener {
11890 fn default() -> Self {
11891 Self::new_with_null_ptr()
11892 }
11893 }
11894 impl NewWithNullPtr for wire_cst_bitcoin_address_data {
11895 fn new_with_null_ptr() -> Self {
11896 Self {
11897 address: core::ptr::null_mut(),
11898 network: Default::default(),
11899 amount_sat: core::ptr::null_mut(),
11900 label: core::ptr::null_mut(),
11901 message: core::ptr::null_mut(),
11902 }
11903 }
11904 }
11905 impl Default for wire_cst_bitcoin_address_data {
11906 fn default() -> Self {
11907 Self::new_with_null_ptr()
11908 }
11909 }
11910 impl NewWithNullPtr for wire_cst_blockchain_explorer {
11911 fn new_with_null_ptr() -> Self {
11912 Self {
11913 tag: -1,
11914 kind: BlockchainExplorerKind { nil__: () },
11915 }
11916 }
11917 }
11918 impl Default for wire_cst_blockchain_explorer {
11919 fn default() -> Self {
11920 Self::new_with_null_ptr()
11921 }
11922 }
11923 impl NewWithNullPtr for wire_cst_blockchain_info {
11924 fn new_with_null_ptr() -> Self {
11925 Self {
11926 liquid_tip: Default::default(),
11927 bitcoin_tip: Default::default(),
11928 }
11929 }
11930 }
11931 impl Default for wire_cst_blockchain_info {
11932 fn default() -> Self {
11933 Self::new_with_null_ptr()
11934 }
11935 }
11936 impl NewWithNullPtr for wire_cst_buy_bitcoin_request {
11937 fn new_with_null_ptr() -> Self {
11938 Self {
11939 prepare_response: Default::default(),
11940 redirect_url: core::ptr::null_mut(),
11941 }
11942 }
11943 }
11944 impl Default for wire_cst_buy_bitcoin_request {
11945 fn default() -> Self {
11946 Self::new_with_null_ptr()
11947 }
11948 }
11949 impl NewWithNullPtr for wire_cst_check_message_request {
11950 fn new_with_null_ptr() -> Self {
11951 Self {
11952 message: core::ptr::null_mut(),
11953 pubkey: core::ptr::null_mut(),
11954 signature: core::ptr::null_mut(),
11955 }
11956 }
11957 }
11958 impl Default for wire_cst_check_message_request {
11959 fn default() -> Self {
11960 Self::new_with_null_ptr()
11961 }
11962 }
11963 impl NewWithNullPtr for wire_cst_check_message_response {
11964 fn new_with_null_ptr() -> Self {
11965 Self {
11966 is_valid: Default::default(),
11967 }
11968 }
11969 }
11970 impl Default for wire_cst_check_message_response {
11971 fn default() -> Self {
11972 Self::new_with_null_ptr()
11973 }
11974 }
11975 impl NewWithNullPtr for wire_cst_config {
11976 fn new_with_null_ptr() -> Self {
11977 Self {
11978 liquid_explorer: Default::default(),
11979 bitcoin_explorer: Default::default(),
11980 working_dir: core::ptr::null_mut(),
11981 cache_dir: core::ptr::null_mut(),
11982 network: Default::default(),
11983 payment_timeout_sec: Default::default(),
11984 sync_service_url: core::ptr::null_mut(),
11985 zero_conf_max_amount_sat: core::ptr::null_mut(),
11986 breez_api_key: core::ptr::null_mut(),
11987 external_input_parsers: core::ptr::null_mut(),
11988 use_default_external_input_parsers: Default::default(),
11989 onchain_fee_rate_leeway_sat_per_vbyte: core::ptr::null_mut(),
11990 asset_metadata: core::ptr::null_mut(),
11991 sideswap_api_key: core::ptr::null_mut(),
11992 }
11993 }
11994 }
11995 impl Default for wire_cst_config {
11996 fn default() -> Self {
11997 Self::new_with_null_ptr()
11998 }
11999 }
12000 impl NewWithNullPtr for wire_cst_connect_request {
12001 fn new_with_null_ptr() -> Self {
12002 Self {
12003 config: Default::default(),
12004 mnemonic: core::ptr::null_mut(),
12005 passphrase: core::ptr::null_mut(),
12006 seed: core::ptr::null_mut(),
12007 }
12008 }
12009 }
12010 impl Default for wire_cst_connect_request {
12011 fn default() -> Self {
12012 Self::new_with_null_ptr()
12013 }
12014 }
12015 impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_request {
12016 fn new_with_null_ptr() -> Self {
12017 Self {
12018 offer: core::ptr::null_mut(),
12019 invoice_request: core::ptr::null_mut(),
12020 }
12021 }
12022 }
12023 impl Default for wire_cst_create_bolt_12_invoice_request {
12024 fn default() -> Self {
12025 Self::new_with_null_ptr()
12026 }
12027 }
12028 impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_response {
12029 fn new_with_null_ptr() -> Self {
12030 Self {
12031 invoice: core::ptr::null_mut(),
12032 }
12033 }
12034 }
12035 impl Default for wire_cst_create_bolt_12_invoice_response {
12036 fn default() -> Self {
12037 Self::new_with_null_ptr()
12038 }
12039 }
12040 impl NewWithNullPtr for wire_cst_currency_info {
12041 fn new_with_null_ptr() -> Self {
12042 Self {
12043 name: core::ptr::null_mut(),
12044 fraction_size: Default::default(),
12045 spacing: core::ptr::null_mut(),
12046 symbol: core::ptr::null_mut(),
12047 uniq_symbol: core::ptr::null_mut(),
12048 localized_name: core::ptr::null_mut(),
12049 locale_overrides: core::ptr::null_mut(),
12050 }
12051 }
12052 }
12053 impl Default for wire_cst_currency_info {
12054 fn default() -> Self {
12055 Self::new_with_null_ptr()
12056 }
12057 }
12058 impl NewWithNullPtr for wire_cst_external_input_parser {
12059 fn new_with_null_ptr() -> Self {
12060 Self {
12061 provider_id: core::ptr::null_mut(),
12062 input_regex: core::ptr::null_mut(),
12063 parser_url: core::ptr::null_mut(),
12064 }
12065 }
12066 }
12067 impl Default for wire_cst_external_input_parser {
12068 fn default() -> Self {
12069 Self::new_with_null_ptr()
12070 }
12071 }
12072 impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_request {
12073 fn new_with_null_ptr() -> Self {
12074 Self {
12075 swap_id: core::ptr::null_mut(),
12076 }
12077 }
12078 }
12079 impl Default for wire_cst_fetch_payment_proposed_fees_request {
12080 fn default() -> Self {
12081 Self::new_with_null_ptr()
12082 }
12083 }
12084 impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_response {
12085 fn new_with_null_ptr() -> Self {
12086 Self {
12087 swap_id: core::ptr::null_mut(),
12088 fees_sat: Default::default(),
12089 payer_amount_sat: Default::default(),
12090 receiver_amount_sat: Default::default(),
12091 }
12092 }
12093 }
12094 impl Default for wire_cst_fetch_payment_proposed_fees_response {
12095 fn default() -> Self {
12096 Self::new_with_null_ptr()
12097 }
12098 }
12099 impl NewWithNullPtr for wire_cst_fiat_currency {
12100 fn new_with_null_ptr() -> Self {
12101 Self {
12102 id: core::ptr::null_mut(),
12103 info: Default::default(),
12104 }
12105 }
12106 }
12107 impl Default for wire_cst_fiat_currency {
12108 fn default() -> Self {
12109 Self::new_with_null_ptr()
12110 }
12111 }
12112 impl NewWithNullPtr for wire_cst_get_info_response {
12113 fn new_with_null_ptr() -> Self {
12114 Self {
12115 wallet_info: Default::default(),
12116 blockchain_info: Default::default(),
12117 }
12118 }
12119 }
12120 impl Default for wire_cst_get_info_response {
12121 fn default() -> Self {
12122 Self::new_with_null_ptr()
12123 }
12124 }
12125 impl NewWithNullPtr for wire_cst_get_payment_request {
12126 fn new_with_null_ptr() -> Self {
12127 Self {
12128 tag: -1,
12129 kind: GetPaymentRequestKind { nil__: () },
12130 }
12131 }
12132 }
12133 impl Default for wire_cst_get_payment_request {
12134 fn default() -> Self {
12135 Self::new_with_null_ptr()
12136 }
12137 }
12138 impl NewWithNullPtr for wire_cst_input_type {
12139 fn new_with_null_ptr() -> Self {
12140 Self {
12141 tag: -1,
12142 kind: InputTypeKind { nil__: () },
12143 }
12144 }
12145 }
12146 impl Default for wire_cst_input_type {
12147 fn default() -> Self {
12148 Self::new_with_null_ptr()
12149 }
12150 }
12151 impl NewWithNullPtr for wire_cst_lightning_payment_limits_response {
12152 fn new_with_null_ptr() -> Self {
12153 Self {
12154 send: Default::default(),
12155 receive: Default::default(),
12156 }
12157 }
12158 }
12159 impl Default for wire_cst_lightning_payment_limits_response {
12160 fn default() -> Self {
12161 Self::new_with_null_ptr()
12162 }
12163 }
12164 impl NewWithNullPtr for wire_cst_limits {
12165 fn new_with_null_ptr() -> Self {
12166 Self {
12167 min_sat: Default::default(),
12168 max_sat: Default::default(),
12169 max_zero_conf_sat: Default::default(),
12170 }
12171 }
12172 }
12173 impl Default for wire_cst_limits {
12174 fn default() -> Self {
12175 Self::new_with_null_ptr()
12176 }
12177 }
12178 impl NewWithNullPtr for wire_cst_liquid_address_data {
12179 fn new_with_null_ptr() -> Self {
12180 Self {
12181 address: core::ptr::null_mut(),
12182 network: Default::default(),
12183 asset_id: core::ptr::null_mut(),
12184 amount: core::ptr::null_mut(),
12185 amount_sat: core::ptr::null_mut(),
12186 label: core::ptr::null_mut(),
12187 message: core::ptr::null_mut(),
12188 }
12189 }
12190 }
12191 impl Default for wire_cst_liquid_address_data {
12192 fn default() -> Self {
12193 Self::new_with_null_ptr()
12194 }
12195 }
12196 impl NewWithNullPtr for wire_cst_list_payment_details {
12197 fn new_with_null_ptr() -> Self {
12198 Self {
12199 tag: -1,
12200 kind: ListPaymentDetailsKind { nil__: () },
12201 }
12202 }
12203 }
12204 impl Default for wire_cst_list_payment_details {
12205 fn default() -> Self {
12206 Self::new_with_null_ptr()
12207 }
12208 }
12209 impl NewWithNullPtr for wire_cst_list_payments_request {
12210 fn new_with_null_ptr() -> Self {
12211 Self {
12212 filters: core::ptr::null_mut(),
12213 states: core::ptr::null_mut(),
12214 from_timestamp: core::ptr::null_mut(),
12215 to_timestamp: core::ptr::null_mut(),
12216 offset: core::ptr::null_mut(),
12217 limit: core::ptr::null_mut(),
12218 details: core::ptr::null_mut(),
12219 sort_ascending: core::ptr::null_mut(),
12220 }
12221 }
12222 }
12223 impl Default for wire_cst_list_payments_request {
12224 fn default() -> Self {
12225 Self::new_with_null_ptr()
12226 }
12227 }
12228 impl NewWithNullPtr for wire_cst_ln_invoice {
12229 fn new_with_null_ptr() -> Self {
12230 Self {
12231 bolt11: core::ptr::null_mut(),
12232 network: Default::default(),
12233 payee_pubkey: core::ptr::null_mut(),
12234 payment_hash: core::ptr::null_mut(),
12235 description: core::ptr::null_mut(),
12236 description_hash: core::ptr::null_mut(),
12237 amount_msat: core::ptr::null_mut(),
12238 timestamp: Default::default(),
12239 expiry: Default::default(),
12240 routing_hints: core::ptr::null_mut(),
12241 payment_secret: core::ptr::null_mut(),
12242 min_final_cltv_expiry_delta: Default::default(),
12243 }
12244 }
12245 }
12246 impl Default for wire_cst_ln_invoice {
12247 fn default() -> Self {
12248 Self::new_with_null_ptr()
12249 }
12250 }
12251 impl NewWithNullPtr for wire_cst_ln_offer {
12252 fn new_with_null_ptr() -> Self {
12253 Self {
12254 offer: core::ptr::null_mut(),
12255 chains: core::ptr::null_mut(),
12256 min_amount: core::ptr::null_mut(),
12257 description: core::ptr::null_mut(),
12258 absolute_expiry: core::ptr::null_mut(),
12259 issuer: core::ptr::null_mut(),
12260 signing_pubkey: core::ptr::null_mut(),
12261 paths: core::ptr::null_mut(),
12262 }
12263 }
12264 }
12265 impl Default for wire_cst_ln_offer {
12266 fn default() -> Self {
12267 Self::new_with_null_ptr()
12268 }
12269 }
12270 impl NewWithNullPtr for wire_cst_ln_offer_blinded_path {
12271 fn new_with_null_ptr() -> Self {
12272 Self {
12273 blinded_hops: core::ptr::null_mut(),
12274 }
12275 }
12276 }
12277 impl Default for wire_cst_ln_offer_blinded_path {
12278 fn default() -> Self {
12279 Self::new_with_null_ptr()
12280 }
12281 }
12282 impl NewWithNullPtr for wire_cst_ln_url_auth_error {
12283 fn new_with_null_ptr() -> Self {
12284 Self {
12285 tag: -1,
12286 kind: LnUrlAuthErrorKind { nil__: () },
12287 }
12288 }
12289 }
12290 impl Default for wire_cst_ln_url_auth_error {
12291 fn default() -> Self {
12292 Self::new_with_null_ptr()
12293 }
12294 }
12295 impl NewWithNullPtr for wire_cst_ln_url_auth_request_data {
12296 fn new_with_null_ptr() -> Self {
12297 Self {
12298 k1: core::ptr::null_mut(),
12299 action: core::ptr::null_mut(),
12300 domain: core::ptr::null_mut(),
12301 url: core::ptr::null_mut(),
12302 }
12303 }
12304 }
12305 impl Default for wire_cst_ln_url_auth_request_data {
12306 fn default() -> Self {
12307 Self::new_with_null_ptr()
12308 }
12309 }
12310 impl NewWithNullPtr for wire_cst_ln_url_callback_status {
12311 fn new_with_null_ptr() -> Self {
12312 Self {
12313 tag: -1,
12314 kind: LnUrlCallbackStatusKind { nil__: () },
12315 }
12316 }
12317 }
12318 impl Default for wire_cst_ln_url_callback_status {
12319 fn default() -> Self {
12320 Self::new_with_null_ptr()
12321 }
12322 }
12323 impl NewWithNullPtr for wire_cst_ln_url_error_data {
12324 fn new_with_null_ptr() -> Self {
12325 Self {
12326 reason: core::ptr::null_mut(),
12327 }
12328 }
12329 }
12330 impl Default for wire_cst_ln_url_error_data {
12331 fn default() -> Self {
12332 Self::new_with_null_ptr()
12333 }
12334 }
12335 impl NewWithNullPtr for wire_cst_ln_url_info {
12336 fn new_with_null_ptr() -> Self {
12337 Self {
12338 ln_address: core::ptr::null_mut(),
12339 lnurl_pay_comment: core::ptr::null_mut(),
12340 lnurl_pay_domain: core::ptr::null_mut(),
12341 lnurl_pay_metadata: core::ptr::null_mut(),
12342 lnurl_pay_success_action: core::ptr::null_mut(),
12343 lnurl_pay_unprocessed_success_action: core::ptr::null_mut(),
12344 lnurl_withdraw_endpoint: core::ptr::null_mut(),
12345 }
12346 }
12347 }
12348 impl Default for wire_cst_ln_url_info {
12349 fn default() -> Self {
12350 Self::new_with_null_ptr()
12351 }
12352 }
12353 impl NewWithNullPtr for wire_cst_ln_url_pay_error {
12354 fn new_with_null_ptr() -> Self {
12355 Self {
12356 tag: -1,
12357 kind: LnUrlPayErrorKind { nil__: () },
12358 }
12359 }
12360 }
12361 impl Default for wire_cst_ln_url_pay_error {
12362 fn default() -> Self {
12363 Self::new_with_null_ptr()
12364 }
12365 }
12366 impl NewWithNullPtr for wire_cst_ln_url_pay_error_data {
12367 fn new_with_null_ptr() -> Self {
12368 Self {
12369 payment_hash: core::ptr::null_mut(),
12370 reason: core::ptr::null_mut(),
12371 }
12372 }
12373 }
12374 impl Default for wire_cst_ln_url_pay_error_data {
12375 fn default() -> Self {
12376 Self::new_with_null_ptr()
12377 }
12378 }
12379 impl NewWithNullPtr for wire_cst_ln_url_pay_request {
12380 fn new_with_null_ptr() -> Self {
12381 Self {
12382 prepare_response: Default::default(),
12383 }
12384 }
12385 }
12386 impl Default for wire_cst_ln_url_pay_request {
12387 fn default() -> Self {
12388 Self::new_with_null_ptr()
12389 }
12390 }
12391 impl NewWithNullPtr for wire_cst_ln_url_pay_request_data {
12392 fn new_with_null_ptr() -> Self {
12393 Self {
12394 callback: core::ptr::null_mut(),
12395 min_sendable: Default::default(),
12396 max_sendable: Default::default(),
12397 metadata_str: core::ptr::null_mut(),
12398 comment_allowed: Default::default(),
12399 domain: core::ptr::null_mut(),
12400 allows_nostr: Default::default(),
12401 nostr_pubkey: core::ptr::null_mut(),
12402 ln_address: core::ptr::null_mut(),
12403 }
12404 }
12405 }
12406 impl Default for wire_cst_ln_url_pay_request_data {
12407 fn default() -> Self {
12408 Self::new_with_null_ptr()
12409 }
12410 }
12411 impl NewWithNullPtr for wire_cst_ln_url_pay_result {
12412 fn new_with_null_ptr() -> Self {
12413 Self {
12414 tag: -1,
12415 kind: LnUrlPayResultKind { nil__: () },
12416 }
12417 }
12418 }
12419 impl Default for wire_cst_ln_url_pay_result {
12420 fn default() -> Self {
12421 Self::new_with_null_ptr()
12422 }
12423 }
12424 impl NewWithNullPtr for wire_cst_ln_url_pay_success_data {
12425 fn new_with_null_ptr() -> Self {
12426 Self {
12427 payment: Default::default(),
12428 success_action: core::ptr::null_mut(),
12429 }
12430 }
12431 }
12432 impl Default for wire_cst_ln_url_pay_success_data {
12433 fn default() -> Self {
12434 Self::new_with_null_ptr()
12435 }
12436 }
12437 impl NewWithNullPtr for wire_cst_ln_url_withdraw_error {
12438 fn new_with_null_ptr() -> Self {
12439 Self {
12440 tag: -1,
12441 kind: LnUrlWithdrawErrorKind { nil__: () },
12442 }
12443 }
12444 }
12445 impl Default for wire_cst_ln_url_withdraw_error {
12446 fn default() -> Self {
12447 Self::new_with_null_ptr()
12448 }
12449 }
12450 impl NewWithNullPtr for wire_cst_ln_url_withdraw_request {
12451 fn new_with_null_ptr() -> Self {
12452 Self {
12453 data: Default::default(),
12454 amount_msat: Default::default(),
12455 description: core::ptr::null_mut(),
12456 }
12457 }
12458 }
12459 impl Default for wire_cst_ln_url_withdraw_request {
12460 fn default() -> Self {
12461 Self::new_with_null_ptr()
12462 }
12463 }
12464 impl NewWithNullPtr for wire_cst_ln_url_withdraw_request_data {
12465 fn new_with_null_ptr() -> Self {
12466 Self {
12467 callback: core::ptr::null_mut(),
12468 k1: core::ptr::null_mut(),
12469 default_description: core::ptr::null_mut(),
12470 min_withdrawable: Default::default(),
12471 max_withdrawable: Default::default(),
12472 }
12473 }
12474 }
12475 impl Default for wire_cst_ln_url_withdraw_request_data {
12476 fn default() -> Self {
12477 Self::new_with_null_ptr()
12478 }
12479 }
12480 impl NewWithNullPtr for wire_cst_ln_url_withdraw_result {
12481 fn new_with_null_ptr() -> Self {
12482 Self {
12483 tag: -1,
12484 kind: LnUrlWithdrawResultKind { nil__: () },
12485 }
12486 }
12487 }
12488 impl Default for wire_cst_ln_url_withdraw_result {
12489 fn default() -> Self {
12490 Self::new_with_null_ptr()
12491 }
12492 }
12493 impl NewWithNullPtr for wire_cst_ln_url_withdraw_success_data {
12494 fn new_with_null_ptr() -> Self {
12495 Self {
12496 invoice: Default::default(),
12497 }
12498 }
12499 }
12500 impl Default for wire_cst_ln_url_withdraw_success_data {
12501 fn default() -> Self {
12502 Self::new_with_null_ptr()
12503 }
12504 }
12505 impl NewWithNullPtr for wire_cst_locale_overrides {
12506 fn new_with_null_ptr() -> Self {
12507 Self {
12508 locale: core::ptr::null_mut(),
12509 spacing: core::ptr::null_mut(),
12510 symbol: Default::default(),
12511 }
12512 }
12513 }
12514 impl Default for wire_cst_locale_overrides {
12515 fn default() -> Self {
12516 Self::new_with_null_ptr()
12517 }
12518 }
12519 impl NewWithNullPtr for wire_cst_localized_name {
12520 fn new_with_null_ptr() -> Self {
12521 Self {
12522 locale: core::ptr::null_mut(),
12523 name: core::ptr::null_mut(),
12524 }
12525 }
12526 }
12527 impl Default for wire_cst_localized_name {
12528 fn default() -> Self {
12529 Self::new_with_null_ptr()
12530 }
12531 }
12532 impl NewWithNullPtr for wire_cst_log_entry {
12533 fn new_with_null_ptr() -> Self {
12534 Self {
12535 line: core::ptr::null_mut(),
12536 level: core::ptr::null_mut(),
12537 }
12538 }
12539 }
12540 impl Default for wire_cst_log_entry {
12541 fn default() -> Self {
12542 Self::new_with_null_ptr()
12543 }
12544 }
12545 impl NewWithNullPtr for wire_cst_message_success_action_data {
12546 fn new_with_null_ptr() -> Self {
12547 Self {
12548 message: core::ptr::null_mut(),
12549 }
12550 }
12551 }
12552 impl Default for wire_cst_message_success_action_data {
12553 fn default() -> Self {
12554 Self::new_with_null_ptr()
12555 }
12556 }
12557 impl NewWithNullPtr for wire_cst_onchain_payment_limits_response {
12558 fn new_with_null_ptr() -> Self {
12559 Self {
12560 send: Default::default(),
12561 receive: Default::default(),
12562 }
12563 }
12564 }
12565 impl Default for wire_cst_onchain_payment_limits_response {
12566 fn default() -> Self {
12567 Self::new_with_null_ptr()
12568 }
12569 }
12570 impl NewWithNullPtr for wire_cst_pay_amount {
12571 fn new_with_null_ptr() -> Self {
12572 Self {
12573 tag: -1,
12574 kind: PayAmountKind { nil__: () },
12575 }
12576 }
12577 }
12578 impl Default for wire_cst_pay_amount {
12579 fn default() -> Self {
12580 Self::new_with_null_ptr()
12581 }
12582 }
12583 impl NewWithNullPtr for wire_cst_pay_onchain_request {
12584 fn new_with_null_ptr() -> Self {
12585 Self {
12586 address: core::ptr::null_mut(),
12587 prepare_response: Default::default(),
12588 }
12589 }
12590 }
12591 impl Default for wire_cst_pay_onchain_request {
12592 fn default() -> Self {
12593 Self::new_with_null_ptr()
12594 }
12595 }
12596 impl NewWithNullPtr for wire_cst_payment {
12597 fn new_with_null_ptr() -> Self {
12598 Self {
12599 destination: core::ptr::null_mut(),
12600 tx_id: core::ptr::null_mut(),
12601 unblinding_data: core::ptr::null_mut(),
12602 timestamp: Default::default(),
12603 amount_sat: Default::default(),
12604 fees_sat: Default::default(),
12605 swapper_fees_sat: core::ptr::null_mut(),
12606 payment_type: Default::default(),
12607 status: Default::default(),
12608 details: Default::default(),
12609 }
12610 }
12611 }
12612 impl Default for wire_cst_payment {
12613 fn default() -> Self {
12614 Self::new_with_null_ptr()
12615 }
12616 }
12617 impl NewWithNullPtr for wire_cst_payment_details {
12618 fn new_with_null_ptr() -> Self {
12619 Self {
12620 tag: -1,
12621 kind: PaymentDetailsKind { nil__: () },
12622 }
12623 }
12624 }
12625 impl Default for wire_cst_payment_details {
12626 fn default() -> Self {
12627 Self::new_with_null_ptr()
12628 }
12629 }
12630 impl NewWithNullPtr for wire_cst_payment_error {
12631 fn new_with_null_ptr() -> Self {
12632 Self {
12633 tag: -1,
12634 kind: PaymentErrorKind { nil__: () },
12635 }
12636 }
12637 }
12638 impl Default for wire_cst_payment_error {
12639 fn default() -> Self {
12640 Self::new_with_null_ptr()
12641 }
12642 }
12643 impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_request {
12644 fn new_with_null_ptr() -> Self {
12645 Self {
12646 provider: Default::default(),
12647 amount_sat: Default::default(),
12648 }
12649 }
12650 }
12651 impl Default for wire_cst_prepare_buy_bitcoin_request {
12652 fn default() -> Self {
12653 Self::new_with_null_ptr()
12654 }
12655 }
12656 impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_response {
12657 fn new_with_null_ptr() -> Self {
12658 Self {
12659 provider: Default::default(),
12660 amount_sat: Default::default(),
12661 fees_sat: Default::default(),
12662 }
12663 }
12664 }
12665 impl Default for wire_cst_prepare_buy_bitcoin_response {
12666 fn default() -> Self {
12667 Self::new_with_null_ptr()
12668 }
12669 }
12670 impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_request {
12671 fn new_with_null_ptr() -> Self {
12672 Self {
12673 data: Default::default(),
12674 amount: Default::default(),
12675 bip353_address: core::ptr::null_mut(),
12676 comment: core::ptr::null_mut(),
12677 validate_success_action_url: core::ptr::null_mut(),
12678 }
12679 }
12680 }
12681 impl Default for wire_cst_prepare_ln_url_pay_request {
12682 fn default() -> Self {
12683 Self::new_with_null_ptr()
12684 }
12685 }
12686 impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_response {
12687 fn new_with_null_ptr() -> Self {
12688 Self {
12689 destination: Default::default(),
12690 fees_sat: Default::default(),
12691 data: Default::default(),
12692 comment: core::ptr::null_mut(),
12693 success_action: core::ptr::null_mut(),
12694 }
12695 }
12696 }
12697 impl Default for wire_cst_prepare_ln_url_pay_response {
12698 fn default() -> Self {
12699 Self::new_with_null_ptr()
12700 }
12701 }
12702 impl NewWithNullPtr for wire_cst_prepare_pay_onchain_request {
12703 fn new_with_null_ptr() -> Self {
12704 Self {
12705 amount: Default::default(),
12706 fee_rate_sat_per_vbyte: core::ptr::null_mut(),
12707 }
12708 }
12709 }
12710 impl Default for wire_cst_prepare_pay_onchain_request {
12711 fn default() -> Self {
12712 Self::new_with_null_ptr()
12713 }
12714 }
12715 impl NewWithNullPtr for wire_cst_prepare_pay_onchain_response {
12716 fn new_with_null_ptr() -> Self {
12717 Self {
12718 receiver_amount_sat: Default::default(),
12719 claim_fees_sat: Default::default(),
12720 total_fees_sat: Default::default(),
12721 }
12722 }
12723 }
12724 impl Default for wire_cst_prepare_pay_onchain_response {
12725 fn default() -> Self {
12726 Self::new_with_null_ptr()
12727 }
12728 }
12729 impl NewWithNullPtr for wire_cst_prepare_receive_request {
12730 fn new_with_null_ptr() -> Self {
12731 Self {
12732 payment_method: Default::default(),
12733 amount: core::ptr::null_mut(),
12734 }
12735 }
12736 }
12737 impl Default for wire_cst_prepare_receive_request {
12738 fn default() -> Self {
12739 Self::new_with_null_ptr()
12740 }
12741 }
12742 impl NewWithNullPtr for wire_cst_prepare_receive_response {
12743 fn new_with_null_ptr() -> Self {
12744 Self {
12745 payment_method: Default::default(),
12746 fees_sat: Default::default(),
12747 amount: core::ptr::null_mut(),
12748 min_payer_amount_sat: core::ptr::null_mut(),
12749 max_payer_amount_sat: core::ptr::null_mut(),
12750 swapper_feerate: core::ptr::null_mut(),
12751 }
12752 }
12753 }
12754 impl Default for wire_cst_prepare_receive_response {
12755 fn default() -> Self {
12756 Self::new_with_null_ptr()
12757 }
12758 }
12759 impl NewWithNullPtr for wire_cst_prepare_refund_request {
12760 fn new_with_null_ptr() -> Self {
12761 Self {
12762 swap_address: core::ptr::null_mut(),
12763 refund_address: core::ptr::null_mut(),
12764 fee_rate_sat_per_vbyte: Default::default(),
12765 }
12766 }
12767 }
12768 impl Default for wire_cst_prepare_refund_request {
12769 fn default() -> Self {
12770 Self::new_with_null_ptr()
12771 }
12772 }
12773 impl NewWithNullPtr for wire_cst_prepare_refund_response {
12774 fn new_with_null_ptr() -> Self {
12775 Self {
12776 tx_vsize: Default::default(),
12777 tx_fee_sat: Default::default(),
12778 last_refund_tx_id: core::ptr::null_mut(),
12779 }
12780 }
12781 }
12782 impl Default for wire_cst_prepare_refund_response {
12783 fn default() -> Self {
12784 Self::new_with_null_ptr()
12785 }
12786 }
12787 impl NewWithNullPtr for wire_cst_prepare_send_request {
12788 fn new_with_null_ptr() -> Self {
12789 Self {
12790 destination: core::ptr::null_mut(),
12791 amount: core::ptr::null_mut(),
12792 }
12793 }
12794 }
12795 impl Default for wire_cst_prepare_send_request {
12796 fn default() -> Self {
12797 Self::new_with_null_ptr()
12798 }
12799 }
12800 impl NewWithNullPtr for wire_cst_prepare_send_response {
12801 fn new_with_null_ptr() -> Self {
12802 Self {
12803 destination: Default::default(),
12804 fees_sat: core::ptr::null_mut(),
12805 estimated_asset_fees: core::ptr::null_mut(),
12806 }
12807 }
12808 }
12809 impl Default for wire_cst_prepare_send_response {
12810 fn default() -> Self {
12811 Self::new_with_null_ptr()
12812 }
12813 }
12814 impl NewWithNullPtr for wire_cst_rate {
12815 fn new_with_null_ptr() -> Self {
12816 Self {
12817 coin: core::ptr::null_mut(),
12818 value: Default::default(),
12819 }
12820 }
12821 }
12822 impl Default for wire_cst_rate {
12823 fn default() -> Self {
12824 Self::new_with_null_ptr()
12825 }
12826 }
12827 impl NewWithNullPtr for wire_cst_receive_amount {
12828 fn new_with_null_ptr() -> Self {
12829 Self {
12830 tag: -1,
12831 kind: ReceiveAmountKind { nil__: () },
12832 }
12833 }
12834 }
12835 impl Default for wire_cst_receive_amount {
12836 fn default() -> Self {
12837 Self::new_with_null_ptr()
12838 }
12839 }
12840 impl NewWithNullPtr for wire_cst_receive_payment_request {
12841 fn new_with_null_ptr() -> Self {
12842 Self {
12843 prepare_response: Default::default(),
12844 description: core::ptr::null_mut(),
12845 use_description_hash: core::ptr::null_mut(),
12846 }
12847 }
12848 }
12849 impl Default for wire_cst_receive_payment_request {
12850 fn default() -> Self {
12851 Self::new_with_null_ptr()
12852 }
12853 }
12854 impl NewWithNullPtr for wire_cst_receive_payment_response {
12855 fn new_with_null_ptr() -> Self {
12856 Self {
12857 destination: core::ptr::null_mut(),
12858 }
12859 }
12860 }
12861 impl Default for wire_cst_receive_payment_response {
12862 fn default() -> Self {
12863 Self::new_with_null_ptr()
12864 }
12865 }
12866 impl NewWithNullPtr for wire_cst_recommended_fees {
12867 fn new_with_null_ptr() -> Self {
12868 Self {
12869 fastest_fee: Default::default(),
12870 half_hour_fee: Default::default(),
12871 hour_fee: Default::default(),
12872 economy_fee: Default::default(),
12873 minimum_fee: Default::default(),
12874 }
12875 }
12876 }
12877 impl Default for wire_cst_recommended_fees {
12878 fn default() -> Self {
12879 Self::new_with_null_ptr()
12880 }
12881 }
12882 impl NewWithNullPtr for wire_cst_refund_request {
12883 fn new_with_null_ptr() -> Self {
12884 Self {
12885 swap_address: core::ptr::null_mut(),
12886 refund_address: core::ptr::null_mut(),
12887 fee_rate_sat_per_vbyte: Default::default(),
12888 }
12889 }
12890 }
12891 impl Default for wire_cst_refund_request {
12892 fn default() -> Self {
12893 Self::new_with_null_ptr()
12894 }
12895 }
12896 impl NewWithNullPtr for wire_cst_refund_response {
12897 fn new_with_null_ptr() -> Self {
12898 Self {
12899 refund_tx_id: core::ptr::null_mut(),
12900 }
12901 }
12902 }
12903 impl Default for wire_cst_refund_response {
12904 fn default() -> Self {
12905 Self::new_with_null_ptr()
12906 }
12907 }
12908 impl NewWithNullPtr for wire_cst_refundable_swap {
12909 fn new_with_null_ptr() -> Self {
12910 Self {
12911 swap_address: core::ptr::null_mut(),
12912 timestamp: Default::default(),
12913 amount_sat: Default::default(),
12914 last_refund_tx_id: core::ptr::null_mut(),
12915 }
12916 }
12917 }
12918 impl Default for wire_cst_refundable_swap {
12919 fn default() -> Self {
12920 Self::new_with_null_ptr()
12921 }
12922 }
12923 impl NewWithNullPtr for wire_cst_restore_request {
12924 fn new_with_null_ptr() -> Self {
12925 Self {
12926 backup_path: core::ptr::null_mut(),
12927 }
12928 }
12929 }
12930 impl Default for wire_cst_restore_request {
12931 fn default() -> Self {
12932 Self::new_with_null_ptr()
12933 }
12934 }
12935 impl NewWithNullPtr for wire_cst_route_hint {
12936 fn new_with_null_ptr() -> Self {
12937 Self {
12938 hops: core::ptr::null_mut(),
12939 }
12940 }
12941 }
12942 impl Default for wire_cst_route_hint {
12943 fn default() -> Self {
12944 Self::new_with_null_ptr()
12945 }
12946 }
12947 impl NewWithNullPtr for wire_cst_route_hint_hop {
12948 fn new_with_null_ptr() -> Self {
12949 Self {
12950 src_node_id: core::ptr::null_mut(),
12951 short_channel_id: core::ptr::null_mut(),
12952 fees_base_msat: Default::default(),
12953 fees_proportional_millionths: Default::default(),
12954 cltv_expiry_delta: Default::default(),
12955 htlc_minimum_msat: core::ptr::null_mut(),
12956 htlc_maximum_msat: core::ptr::null_mut(),
12957 }
12958 }
12959 }
12960 impl Default for wire_cst_route_hint_hop {
12961 fn default() -> Self {
12962 Self::new_with_null_ptr()
12963 }
12964 }
12965 impl NewWithNullPtr for wire_cst_sdk_error {
12966 fn new_with_null_ptr() -> Self {
12967 Self {
12968 tag: -1,
12969 kind: SdkErrorKind { nil__: () },
12970 }
12971 }
12972 }
12973 impl Default for wire_cst_sdk_error {
12974 fn default() -> Self {
12975 Self::new_with_null_ptr()
12976 }
12977 }
12978 impl NewWithNullPtr for wire_cst_sdk_event {
12979 fn new_with_null_ptr() -> Self {
12980 Self {
12981 tag: -1,
12982 kind: SdkEventKind { nil__: () },
12983 }
12984 }
12985 }
12986 impl Default for wire_cst_sdk_event {
12987 fn default() -> Self {
12988 Self::new_with_null_ptr()
12989 }
12990 }
12991 impl NewWithNullPtr for wire_cst_send_destination {
12992 fn new_with_null_ptr() -> Self {
12993 Self {
12994 tag: -1,
12995 kind: SendDestinationKind { nil__: () },
12996 }
12997 }
12998 }
12999 impl Default for wire_cst_send_destination {
13000 fn default() -> Self {
13001 Self::new_with_null_ptr()
13002 }
13003 }
13004 impl NewWithNullPtr for wire_cst_send_payment_request {
13005 fn new_with_null_ptr() -> Self {
13006 Self {
13007 prepare_response: Default::default(),
13008 use_asset_fees: core::ptr::null_mut(),
13009 }
13010 }
13011 }
13012 impl Default for wire_cst_send_payment_request {
13013 fn default() -> Self {
13014 Self::new_with_null_ptr()
13015 }
13016 }
13017 impl NewWithNullPtr for wire_cst_send_payment_response {
13018 fn new_with_null_ptr() -> Self {
13019 Self {
13020 payment: Default::default(),
13021 }
13022 }
13023 }
13024 impl Default for wire_cst_send_payment_response {
13025 fn default() -> Self {
13026 Self::new_with_null_ptr()
13027 }
13028 }
13029 impl NewWithNullPtr for wire_cst_sign_message_request {
13030 fn new_with_null_ptr() -> Self {
13031 Self {
13032 message: core::ptr::null_mut(),
13033 }
13034 }
13035 }
13036 impl Default for wire_cst_sign_message_request {
13037 fn default() -> Self {
13038 Self::new_with_null_ptr()
13039 }
13040 }
13041 impl NewWithNullPtr for wire_cst_sign_message_response {
13042 fn new_with_null_ptr() -> Self {
13043 Self {
13044 signature: core::ptr::null_mut(),
13045 }
13046 }
13047 }
13048 impl Default for wire_cst_sign_message_response {
13049 fn default() -> Self {
13050 Self::new_with_null_ptr()
13051 }
13052 }
13053 impl NewWithNullPtr for wire_cst_success_action {
13054 fn new_with_null_ptr() -> Self {
13055 Self {
13056 tag: -1,
13057 kind: SuccessActionKind { nil__: () },
13058 }
13059 }
13060 }
13061 impl Default for wire_cst_success_action {
13062 fn default() -> Self {
13063 Self::new_with_null_ptr()
13064 }
13065 }
13066 impl NewWithNullPtr for wire_cst_success_action_processed {
13067 fn new_with_null_ptr() -> Self {
13068 Self {
13069 tag: -1,
13070 kind: SuccessActionProcessedKind { nil__: () },
13071 }
13072 }
13073 }
13074 impl Default for wire_cst_success_action_processed {
13075 fn default() -> Self {
13076 Self::new_with_null_ptr()
13077 }
13078 }
13079 impl NewWithNullPtr for wire_cst_symbol {
13080 fn new_with_null_ptr() -> Self {
13081 Self {
13082 grapheme: core::ptr::null_mut(),
13083 template: core::ptr::null_mut(),
13084 rtl: core::ptr::null_mut(),
13085 position: core::ptr::null_mut(),
13086 }
13087 }
13088 }
13089 impl Default for wire_cst_symbol {
13090 fn default() -> Self {
13091 Self::new_with_null_ptr()
13092 }
13093 }
13094 impl NewWithNullPtr for wire_cst_url_success_action_data {
13095 fn new_with_null_ptr() -> Self {
13096 Self {
13097 description: core::ptr::null_mut(),
13098 url: core::ptr::null_mut(),
13099 matches_callback_domain: Default::default(),
13100 }
13101 }
13102 }
13103 impl Default for wire_cst_url_success_action_data {
13104 fn default() -> Self {
13105 Self::new_with_null_ptr()
13106 }
13107 }
13108 impl NewWithNullPtr for wire_cst_wallet_info {
13109 fn new_with_null_ptr() -> Self {
13110 Self {
13111 balance_sat: Default::default(),
13112 pending_send_sat: Default::default(),
13113 pending_receive_sat: Default::default(),
13114 fingerprint: core::ptr::null_mut(),
13115 pubkey: core::ptr::null_mut(),
13116 asset_balances: core::ptr::null_mut(),
13117 }
13118 }
13119 }
13120 impl Default for wire_cst_wallet_info {
13121 fn default() -> Self {
13122 Self::new_with_null_ptr()
13123 }
13124 }
13125
13126 #[unsafe(no_mangle)]
13127 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees(
13128 port_: i64,
13129 that: usize,
13130 req: *mut wire_cst_accept_payment_proposed_fees_request,
13131 ) {
13132 wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(port_, that, req)
13133 }
13134
13135 #[unsafe(no_mangle)]
13136 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_add_event_listener(
13137 port_: i64,
13138 that: usize,
13139 listener: *mut wire_cst_list_prim_u_8_strict,
13140 ) {
13141 wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(port_, that, listener)
13142 }
13143
13144 #[unsafe(no_mangle)]
13145 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_backup(
13146 that: usize,
13147 req: *mut wire_cst_backup_request,
13148 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13149 wire__crate__bindings__BindingLiquidSdk_backup_impl(that, req)
13150 }
13151
13152 #[unsafe(no_mangle)]
13153 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_buy_bitcoin(
13154 port_: i64,
13155 that: usize,
13156 req: *mut wire_cst_buy_bitcoin_request,
13157 ) {
13158 wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(port_, that, req)
13159 }
13160
13161 #[unsafe(no_mangle)]
13162 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_check_message(
13163 that: usize,
13164 req: *mut wire_cst_check_message_request,
13165 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13166 wire__crate__bindings__BindingLiquidSdk_check_message_impl(that, req)
13167 }
13168
13169 #[unsafe(no_mangle)]
13170 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice(
13171 port_: i64,
13172 that: usize,
13173 req: *mut wire_cst_create_bolt_12_invoice_request,
13174 ) {
13175 wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(port_, that, req)
13176 }
13177
13178 #[unsafe(no_mangle)]
13179 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_disconnect(
13180 port_: i64,
13181 that: usize,
13182 ) {
13183 wire__crate__bindings__BindingLiquidSdk_disconnect_impl(port_, that)
13184 }
13185
13186 #[unsafe(no_mangle)]
13187 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache(
13188 that: usize,
13189 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13190 wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(that)
13191 }
13192
13193 #[unsafe(no_mangle)]
13194 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates(
13195 port_: i64,
13196 that: usize,
13197 ) {
13198 wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(port_, that)
13199 }
13200
13201 #[unsafe(no_mangle)]
13202 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
13203 port_: i64,
13204 that: usize,
13205 ) {
13206 wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(port_, that)
13207 }
13208
13209 #[unsafe(no_mangle)]
13210 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
13211 port_: i64,
13212 that: usize,
13213 ) {
13214 wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(port_, that)
13215 }
13216
13217 #[unsafe(no_mangle)]
13218 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees(
13219 port_: i64,
13220 that: usize,
13221 req: *mut wire_cst_fetch_payment_proposed_fees_request,
13222 ) {
13223 wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(port_, that, req)
13224 }
13225
13226 #[unsafe(no_mangle)]
13227 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info(
13228 port_: i64,
13229 that: usize,
13230 ) {
13231 wire__crate__bindings__BindingLiquidSdk_get_info_impl(port_, that)
13232 }
13233
13234 #[unsafe(no_mangle)]
13235 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_payment(
13236 port_: i64,
13237 that: usize,
13238 req: *mut wire_cst_get_payment_request,
13239 ) {
13240 wire__crate__bindings__BindingLiquidSdk_get_payment_impl(port_, that, req)
13241 }
13242
13243 #[unsafe(no_mangle)]
13244 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies(
13245 port_: i64,
13246 that: usize,
13247 ) {
13248 wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(port_, that)
13249 }
13250
13251 #[unsafe(no_mangle)]
13252 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_payments(
13253 port_: i64,
13254 that: usize,
13255 req: *mut wire_cst_list_payments_request,
13256 ) {
13257 wire__crate__bindings__BindingLiquidSdk_list_payments_impl(port_, that, req)
13258 }
13259
13260 #[unsafe(no_mangle)]
13261 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_refundables(
13262 port_: i64,
13263 that: usize,
13264 ) {
13265 wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(port_, that)
13266 }
13267
13268 #[unsafe(no_mangle)]
13269 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_auth(
13270 port_: i64,
13271 that: usize,
13272 req_data: *mut wire_cst_ln_url_auth_request_data,
13273 ) {
13274 wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(port_, that, req_data)
13275 }
13276
13277 #[unsafe(no_mangle)]
13278 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_pay(
13279 port_: i64,
13280 that: usize,
13281 req: *mut wire_cst_ln_url_pay_request,
13282 ) {
13283 wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(port_, that, req)
13284 }
13285
13286 #[unsafe(no_mangle)]
13287 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw(
13288 port_: i64,
13289 that: usize,
13290 req: *mut wire_cst_ln_url_withdraw_request,
13291 ) {
13292 wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(port_, that, req)
13293 }
13294
13295 #[unsafe(no_mangle)]
13296 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_parse(
13297 port_: i64,
13298 that: usize,
13299 input: *mut wire_cst_list_prim_u_8_strict,
13300 ) {
13301 wire__crate__bindings__BindingLiquidSdk_parse_impl(port_, that, input)
13302 }
13303
13304 #[unsafe(no_mangle)]
13305 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_pay_onchain(
13306 port_: i64,
13307 that: usize,
13308 req: *mut wire_cst_pay_onchain_request,
13309 ) {
13310 wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(port_, that, req)
13311 }
13312
13313 #[unsafe(no_mangle)]
13314 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin(
13315 port_: i64,
13316 that: usize,
13317 req: *mut wire_cst_prepare_buy_bitcoin_request,
13318 ) {
13319 wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(port_, that, req)
13320 }
13321
13322 #[unsafe(no_mangle)]
13323 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay(
13324 port_: i64,
13325 that: usize,
13326 req: *mut wire_cst_prepare_ln_url_pay_request,
13327 ) {
13328 wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(port_, that, req)
13329 }
13330
13331 #[unsafe(no_mangle)]
13332 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain(
13333 port_: i64,
13334 that: usize,
13335 req: *mut wire_cst_prepare_pay_onchain_request,
13336 ) {
13337 wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(port_, that, req)
13338 }
13339
13340 #[unsafe(no_mangle)]
13341 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment(
13342 port_: i64,
13343 that: usize,
13344 req: *mut wire_cst_prepare_receive_request,
13345 ) {
13346 wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(port_, that, req)
13347 }
13348
13349 #[unsafe(no_mangle)]
13350 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_refund(
13351 port_: i64,
13352 that: usize,
13353 req: *mut wire_cst_prepare_refund_request,
13354 ) {
13355 wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(port_, that, req)
13356 }
13357
13358 #[unsafe(no_mangle)]
13359 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_send_payment(
13360 port_: i64,
13361 that: usize,
13362 req: *mut wire_cst_prepare_send_request,
13363 ) {
13364 wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(port_, that, req)
13365 }
13366
13367 #[unsafe(no_mangle)]
13368 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_receive_payment(
13369 port_: i64,
13370 that: usize,
13371 req: *mut wire_cst_receive_payment_request,
13372 ) {
13373 wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(port_, that, req)
13374 }
13375
13376 #[unsafe(no_mangle)]
13377 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_recommended_fees(
13378 port_: i64,
13379 that: usize,
13380 ) {
13381 wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(port_, that)
13382 }
13383
13384 #[unsafe(no_mangle)]
13385 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_refund(
13386 port_: i64,
13387 that: usize,
13388 req: *mut wire_cst_refund_request,
13389 ) {
13390 wire__crate__bindings__BindingLiquidSdk_refund_impl(port_, that, req)
13391 }
13392
13393 #[unsafe(no_mangle)]
13394 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_register_webhook(
13395 port_: i64,
13396 that: usize,
13397 webhook_url: *mut wire_cst_list_prim_u_8_strict,
13398 ) {
13399 wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(port_, that, webhook_url)
13400 }
13401
13402 #[unsafe(no_mangle)]
13403 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps(
13404 port_: i64,
13405 that: usize,
13406 ) {
13407 wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(port_, that)
13408 }
13409
13410 #[unsafe(no_mangle)]
13411 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_restore(
13412 that: usize,
13413 req: *mut wire_cst_restore_request,
13414 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13415 wire__crate__bindings__BindingLiquidSdk_restore_impl(that, req)
13416 }
13417
13418 #[unsafe(no_mangle)]
13419 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_send_payment(
13420 port_: i64,
13421 that: usize,
13422 req: *mut wire_cst_send_payment_request,
13423 ) {
13424 wire__crate__bindings__BindingLiquidSdk_send_payment_impl(port_, that, req)
13425 }
13426
13427 #[unsafe(no_mangle)]
13428 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sign_message(
13429 that: usize,
13430 req: *mut wire_cst_sign_message_request,
13431 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13432 wire__crate__bindings__BindingLiquidSdk_sign_message_impl(that, req)
13433 }
13434
13435 #[unsafe(no_mangle)]
13436 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sync(
13437 port_: i64,
13438 that: usize,
13439 ) {
13440 wire__crate__bindings__BindingLiquidSdk_sync_impl(port_, that)
13441 }
13442
13443 #[unsafe(no_mangle)]
13444 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_unregister_webhook(
13445 port_: i64,
13446 that: usize,
13447 ) {
13448 wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(port_, that)
13449 }
13450
13451 #[unsafe(no_mangle)]
13452 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__binding_event_listener_on_event(
13453 port_: i64,
13454 that: *mut wire_cst_binding_event_listener,
13455 e: *mut wire_cst_sdk_event,
13456 ) {
13457 wire__crate__bindings__binding_event_listener_on_event_impl(port_, that, e)
13458 }
13459
13460 #[unsafe(no_mangle)]
13461 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__breez_log_stream(
13462 port_: i64,
13463 s: *mut wire_cst_list_prim_u_8_strict,
13464 ) {
13465 wire__crate__bindings__breez_log_stream_impl(port_, s)
13466 }
13467
13468 #[unsafe(no_mangle)]
13469 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__connect(
13470 port_: i64,
13471 req: *mut wire_cst_connect_request,
13472 ) {
13473 wire__crate__bindings__connect_impl(port_, req)
13474 }
13475
13476 #[unsafe(no_mangle)]
13477 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__default_config(
13478 network: i32,
13479 breez_api_key: *mut wire_cst_list_prim_u_8_strict,
13480 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13481 wire__crate__bindings__default_config_impl(network, breez_api_key)
13482 }
13483
13484 #[unsafe(no_mangle)]
13485 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__parse_invoice(
13486 input: *mut wire_cst_list_prim_u_8_strict,
13487 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13488 wire__crate__bindings__parse_invoice_impl(input)
13489 }
13490
13491 #[unsafe(no_mangle)]
13492 pub extern "C" fn frbgen_breez_liquid_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13493 ptr: *const std::ffi::c_void,
13494 ) {
13495 unsafe {
13496 StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::increment_strong_count(ptr as _);
13497 }
13498 }
13499
13500 #[unsafe(no_mangle)]
13501 pub extern "C" fn frbgen_breez_liquid_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13502 ptr: *const std::ffi::c_void,
13503 ) {
13504 unsafe {
13505 StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::decrement_strong_count(ptr as _);
13506 }
13507 }
13508
13509 #[unsafe(no_mangle)]
13510 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_accept_payment_proposed_fees_request(
13511 ) -> *mut wire_cst_accept_payment_proposed_fees_request {
13512 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13513 wire_cst_accept_payment_proposed_fees_request::new_with_null_ptr(),
13514 )
13515 }
13516
13517 #[unsafe(no_mangle)]
13518 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data(
13519 ) -> *mut wire_cst_aes_success_action_data {
13520 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13521 wire_cst_aes_success_action_data::new_with_null_ptr(),
13522 )
13523 }
13524
13525 #[unsafe(no_mangle)]
13526 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_decrypted(
13527 ) -> *mut wire_cst_aes_success_action_data_decrypted {
13528 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13529 wire_cst_aes_success_action_data_decrypted::new_with_null_ptr(),
13530 )
13531 }
13532
13533 #[unsafe(no_mangle)]
13534 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_result(
13535 ) -> *mut wire_cst_aes_success_action_data_result {
13536 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13537 wire_cst_aes_success_action_data_result::new_with_null_ptr(),
13538 )
13539 }
13540
13541 #[unsafe(no_mangle)]
13542 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_amount() -> *mut wire_cst_amount {
13543 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_amount::new_with_null_ptr())
13544 }
13545
13546 #[unsafe(no_mangle)]
13547 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_asset_info(
13548 ) -> *mut wire_cst_asset_info {
13549 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13550 wire_cst_asset_info::new_with_null_ptr(),
13551 )
13552 }
13553
13554 #[unsafe(no_mangle)]
13555 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_backup_request(
13556 ) -> *mut wire_cst_backup_request {
13557 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13558 wire_cst_backup_request::new_with_null_ptr(),
13559 )
13560 }
13561
13562 #[unsafe(no_mangle)]
13563 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_binding_event_listener(
13564 ) -> *mut wire_cst_binding_event_listener {
13565 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13566 wire_cst_binding_event_listener::new_with_null_ptr(),
13567 )
13568 }
13569
13570 #[unsafe(no_mangle)]
13571 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bitcoin_address_data(
13572 ) -> *mut wire_cst_bitcoin_address_data {
13573 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13574 wire_cst_bitcoin_address_data::new_with_null_ptr(),
13575 )
13576 }
13577
13578 #[unsafe(no_mangle)]
13579 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bool(value: bool) -> *mut bool {
13580 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13581 }
13582
13583 #[unsafe(no_mangle)]
13584 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_buy_bitcoin_request(
13585 ) -> *mut wire_cst_buy_bitcoin_request {
13586 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13587 wire_cst_buy_bitcoin_request::new_with_null_ptr(),
13588 )
13589 }
13590
13591 #[unsafe(no_mangle)]
13592 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_check_message_request(
13593 ) -> *mut wire_cst_check_message_request {
13594 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13595 wire_cst_check_message_request::new_with_null_ptr(),
13596 )
13597 }
13598
13599 #[unsafe(no_mangle)]
13600 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_connect_request(
13601 ) -> *mut wire_cst_connect_request {
13602 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13603 wire_cst_connect_request::new_with_null_ptr(),
13604 )
13605 }
13606
13607 #[unsafe(no_mangle)]
13608 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_create_bolt_12_invoice_request(
13609 ) -> *mut wire_cst_create_bolt_12_invoice_request {
13610 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13611 wire_cst_create_bolt_12_invoice_request::new_with_null_ptr(),
13612 )
13613 }
13614
13615 #[unsafe(no_mangle)]
13616 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_f_64(value: f64) -> *mut f64 {
13617 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13618 }
13619
13620 #[unsafe(no_mangle)]
13621 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_fetch_payment_proposed_fees_request(
13622 ) -> *mut wire_cst_fetch_payment_proposed_fees_request {
13623 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13624 wire_cst_fetch_payment_proposed_fees_request::new_with_null_ptr(),
13625 )
13626 }
13627
13628 #[unsafe(no_mangle)]
13629 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_get_payment_request(
13630 ) -> *mut wire_cst_get_payment_request {
13631 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13632 wire_cst_get_payment_request::new_with_null_ptr(),
13633 )
13634 }
13635
13636 #[unsafe(no_mangle)]
13637 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_i_64(value: i64) -> *mut i64 {
13638 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13639 }
13640
13641 #[unsafe(no_mangle)]
13642 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_liquid_address_data(
13643 ) -> *mut wire_cst_liquid_address_data {
13644 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13645 wire_cst_liquid_address_data::new_with_null_ptr(),
13646 )
13647 }
13648
13649 #[unsafe(no_mangle)]
13650 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payment_details(
13651 ) -> *mut wire_cst_list_payment_details {
13652 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13653 wire_cst_list_payment_details::new_with_null_ptr(),
13654 )
13655 }
13656
13657 #[unsafe(no_mangle)]
13658 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payments_request(
13659 ) -> *mut wire_cst_list_payments_request {
13660 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13661 wire_cst_list_payments_request::new_with_null_ptr(),
13662 )
13663 }
13664
13665 #[unsafe(no_mangle)]
13666 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_invoice(
13667 ) -> *mut wire_cst_ln_invoice {
13668 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13669 wire_cst_ln_invoice::new_with_null_ptr(),
13670 )
13671 }
13672
13673 #[unsafe(no_mangle)]
13674 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_offer() -> *mut wire_cst_ln_offer {
13675 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_ln_offer::new_with_null_ptr())
13676 }
13677
13678 #[unsafe(no_mangle)]
13679 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_auth_request_data(
13680 ) -> *mut wire_cst_ln_url_auth_request_data {
13681 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13682 wire_cst_ln_url_auth_request_data::new_with_null_ptr(),
13683 )
13684 }
13685
13686 #[unsafe(no_mangle)]
13687 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_error_data(
13688 ) -> *mut wire_cst_ln_url_error_data {
13689 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13690 wire_cst_ln_url_error_data::new_with_null_ptr(),
13691 )
13692 }
13693
13694 #[unsafe(no_mangle)]
13695 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_info(
13696 ) -> *mut wire_cst_ln_url_info {
13697 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13698 wire_cst_ln_url_info::new_with_null_ptr(),
13699 )
13700 }
13701
13702 #[unsafe(no_mangle)]
13703 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_error_data(
13704 ) -> *mut wire_cst_ln_url_pay_error_data {
13705 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13706 wire_cst_ln_url_pay_error_data::new_with_null_ptr(),
13707 )
13708 }
13709
13710 #[unsafe(no_mangle)]
13711 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request(
13712 ) -> *mut wire_cst_ln_url_pay_request {
13713 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13714 wire_cst_ln_url_pay_request::new_with_null_ptr(),
13715 )
13716 }
13717
13718 #[unsafe(no_mangle)]
13719 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request_data(
13720 ) -> *mut wire_cst_ln_url_pay_request_data {
13721 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13722 wire_cst_ln_url_pay_request_data::new_with_null_ptr(),
13723 )
13724 }
13725
13726 #[unsafe(no_mangle)]
13727 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_success_data(
13728 ) -> *mut wire_cst_ln_url_pay_success_data {
13729 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13730 wire_cst_ln_url_pay_success_data::new_with_null_ptr(),
13731 )
13732 }
13733
13734 #[unsafe(no_mangle)]
13735 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request(
13736 ) -> *mut wire_cst_ln_url_withdraw_request {
13737 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13738 wire_cst_ln_url_withdraw_request::new_with_null_ptr(),
13739 )
13740 }
13741
13742 #[unsafe(no_mangle)]
13743 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request_data(
13744 ) -> *mut wire_cst_ln_url_withdraw_request_data {
13745 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13746 wire_cst_ln_url_withdraw_request_data::new_with_null_ptr(),
13747 )
13748 }
13749
13750 #[unsafe(no_mangle)]
13751 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_success_data(
13752 ) -> *mut wire_cst_ln_url_withdraw_success_data {
13753 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13754 wire_cst_ln_url_withdraw_success_data::new_with_null_ptr(),
13755 )
13756 }
13757
13758 #[unsafe(no_mangle)]
13759 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_message_success_action_data(
13760 ) -> *mut wire_cst_message_success_action_data {
13761 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13762 wire_cst_message_success_action_data::new_with_null_ptr(),
13763 )
13764 }
13765
13766 #[unsafe(no_mangle)]
13767 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_amount(
13768 ) -> *mut wire_cst_pay_amount {
13769 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13770 wire_cst_pay_amount::new_with_null_ptr(),
13771 )
13772 }
13773
13774 #[unsafe(no_mangle)]
13775 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_onchain_request(
13776 ) -> *mut wire_cst_pay_onchain_request {
13777 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13778 wire_cst_pay_onchain_request::new_with_null_ptr(),
13779 )
13780 }
13781
13782 #[unsafe(no_mangle)]
13783 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_payment() -> *mut wire_cst_payment {
13784 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_payment::new_with_null_ptr())
13785 }
13786
13787 #[unsafe(no_mangle)]
13788 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_buy_bitcoin_request(
13789 ) -> *mut wire_cst_prepare_buy_bitcoin_request {
13790 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13791 wire_cst_prepare_buy_bitcoin_request::new_with_null_ptr(),
13792 )
13793 }
13794
13795 #[unsafe(no_mangle)]
13796 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_ln_url_pay_request(
13797 ) -> *mut wire_cst_prepare_ln_url_pay_request {
13798 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13799 wire_cst_prepare_ln_url_pay_request::new_with_null_ptr(),
13800 )
13801 }
13802
13803 #[unsafe(no_mangle)]
13804 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_pay_onchain_request(
13805 ) -> *mut wire_cst_prepare_pay_onchain_request {
13806 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13807 wire_cst_prepare_pay_onchain_request::new_with_null_ptr(),
13808 )
13809 }
13810
13811 #[unsafe(no_mangle)]
13812 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_receive_request(
13813 ) -> *mut wire_cst_prepare_receive_request {
13814 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13815 wire_cst_prepare_receive_request::new_with_null_ptr(),
13816 )
13817 }
13818
13819 #[unsafe(no_mangle)]
13820 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_refund_request(
13821 ) -> *mut wire_cst_prepare_refund_request {
13822 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13823 wire_cst_prepare_refund_request::new_with_null_ptr(),
13824 )
13825 }
13826
13827 #[unsafe(no_mangle)]
13828 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_send_request(
13829 ) -> *mut wire_cst_prepare_send_request {
13830 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13831 wire_cst_prepare_send_request::new_with_null_ptr(),
13832 )
13833 }
13834
13835 #[unsafe(no_mangle)]
13836 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_amount(
13837 ) -> *mut wire_cst_receive_amount {
13838 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13839 wire_cst_receive_amount::new_with_null_ptr(),
13840 )
13841 }
13842
13843 #[unsafe(no_mangle)]
13844 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_payment_request(
13845 ) -> *mut wire_cst_receive_payment_request {
13846 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13847 wire_cst_receive_payment_request::new_with_null_ptr(),
13848 )
13849 }
13850
13851 #[unsafe(no_mangle)]
13852 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_refund_request(
13853 ) -> *mut wire_cst_refund_request {
13854 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13855 wire_cst_refund_request::new_with_null_ptr(),
13856 )
13857 }
13858
13859 #[unsafe(no_mangle)]
13860 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_restore_request(
13861 ) -> *mut wire_cst_restore_request {
13862 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13863 wire_cst_restore_request::new_with_null_ptr(),
13864 )
13865 }
13866
13867 #[unsafe(no_mangle)]
13868 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sdk_event() -> *mut wire_cst_sdk_event
13869 {
13870 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_sdk_event::new_with_null_ptr())
13871 }
13872
13873 #[unsafe(no_mangle)]
13874 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_send_payment_request(
13875 ) -> *mut wire_cst_send_payment_request {
13876 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13877 wire_cst_send_payment_request::new_with_null_ptr(),
13878 )
13879 }
13880
13881 #[unsafe(no_mangle)]
13882 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sign_message_request(
13883 ) -> *mut wire_cst_sign_message_request {
13884 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13885 wire_cst_sign_message_request::new_with_null_ptr(),
13886 )
13887 }
13888
13889 #[unsafe(no_mangle)]
13890 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action(
13891 ) -> *mut wire_cst_success_action {
13892 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13893 wire_cst_success_action::new_with_null_ptr(),
13894 )
13895 }
13896
13897 #[unsafe(no_mangle)]
13898 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action_processed(
13899 ) -> *mut wire_cst_success_action_processed {
13900 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13901 wire_cst_success_action_processed::new_with_null_ptr(),
13902 )
13903 }
13904
13905 #[unsafe(no_mangle)]
13906 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_symbol() -> *mut wire_cst_symbol {
13907 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_symbol::new_with_null_ptr())
13908 }
13909
13910 #[unsafe(no_mangle)]
13911 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_32(value: u32) -> *mut u32 {
13912 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13913 }
13914
13915 #[unsafe(no_mangle)]
13916 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_64(value: u64) -> *mut u64 {
13917 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13918 }
13919
13920 #[unsafe(no_mangle)]
13921 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_url_success_action_data(
13922 ) -> *mut wire_cst_url_success_action_data {
13923 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13924 wire_cst_url_success_action_data::new_with_null_ptr(),
13925 )
13926 }
13927
13928 #[unsafe(no_mangle)]
13929 pub extern "C" fn frbgen_breez_liquid_cst_new_list_String(
13930 len: i32,
13931 ) -> *mut wire_cst_list_String {
13932 let wrap = wire_cst_list_String {
13933 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13934 <*mut wire_cst_list_prim_u_8_strict>::new_with_null_ptr(),
13935 len,
13936 ),
13937 len,
13938 };
13939 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13940 }
13941
13942 #[unsafe(no_mangle)]
13943 pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_balance(
13944 len: i32,
13945 ) -> *mut wire_cst_list_asset_balance {
13946 let wrap = wire_cst_list_asset_balance {
13947 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13948 <wire_cst_asset_balance>::new_with_null_ptr(),
13949 len,
13950 ),
13951 len,
13952 };
13953 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13954 }
13955
13956 #[unsafe(no_mangle)]
13957 pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_metadata(
13958 len: i32,
13959 ) -> *mut wire_cst_list_asset_metadata {
13960 let wrap = wire_cst_list_asset_metadata {
13961 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13962 <wire_cst_asset_metadata>::new_with_null_ptr(),
13963 len,
13964 ),
13965 len,
13966 };
13967 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13968 }
13969
13970 #[unsafe(no_mangle)]
13971 pub extern "C" fn frbgen_breez_liquid_cst_new_list_external_input_parser(
13972 len: i32,
13973 ) -> *mut wire_cst_list_external_input_parser {
13974 let wrap = wire_cst_list_external_input_parser {
13975 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13976 <wire_cst_external_input_parser>::new_with_null_ptr(),
13977 len,
13978 ),
13979 len,
13980 };
13981 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13982 }
13983
13984 #[unsafe(no_mangle)]
13985 pub extern "C" fn frbgen_breez_liquid_cst_new_list_fiat_currency(
13986 len: i32,
13987 ) -> *mut wire_cst_list_fiat_currency {
13988 let wrap = wire_cst_list_fiat_currency {
13989 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13990 <wire_cst_fiat_currency>::new_with_null_ptr(),
13991 len,
13992 ),
13993 len,
13994 };
13995 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13996 }
13997
13998 #[unsafe(no_mangle)]
13999 pub extern "C" fn frbgen_breez_liquid_cst_new_list_ln_offer_blinded_path(
14000 len: i32,
14001 ) -> *mut wire_cst_list_ln_offer_blinded_path {
14002 let wrap = wire_cst_list_ln_offer_blinded_path {
14003 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14004 <wire_cst_ln_offer_blinded_path>::new_with_null_ptr(),
14005 len,
14006 ),
14007 len,
14008 };
14009 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14010 }
14011
14012 #[unsafe(no_mangle)]
14013 pub extern "C" fn frbgen_breez_liquid_cst_new_list_locale_overrides(
14014 len: i32,
14015 ) -> *mut wire_cst_list_locale_overrides {
14016 let wrap = wire_cst_list_locale_overrides {
14017 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14018 <wire_cst_locale_overrides>::new_with_null_ptr(),
14019 len,
14020 ),
14021 len,
14022 };
14023 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14024 }
14025
14026 #[unsafe(no_mangle)]
14027 pub extern "C" fn frbgen_breez_liquid_cst_new_list_localized_name(
14028 len: i32,
14029 ) -> *mut wire_cst_list_localized_name {
14030 let wrap = wire_cst_list_localized_name {
14031 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14032 <wire_cst_localized_name>::new_with_null_ptr(),
14033 len,
14034 ),
14035 len,
14036 };
14037 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14038 }
14039
14040 #[unsafe(no_mangle)]
14041 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment(
14042 len: i32,
14043 ) -> *mut wire_cst_list_payment {
14044 let wrap = wire_cst_list_payment {
14045 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14046 <wire_cst_payment>::new_with_null_ptr(),
14047 len,
14048 ),
14049 len,
14050 };
14051 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14052 }
14053
14054 #[unsafe(no_mangle)]
14055 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_state(
14056 len: i32,
14057 ) -> *mut wire_cst_list_payment_state {
14058 let wrap = wire_cst_list_payment_state {
14059 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14060 len,
14061 };
14062 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14063 }
14064
14065 #[unsafe(no_mangle)]
14066 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_type(
14067 len: i32,
14068 ) -> *mut wire_cst_list_payment_type {
14069 let wrap = wire_cst_list_payment_type {
14070 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14071 len,
14072 };
14073 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14074 }
14075
14076 #[unsafe(no_mangle)]
14077 pub extern "C" fn frbgen_breez_liquid_cst_new_list_prim_u_8_strict(
14078 len: i32,
14079 ) -> *mut wire_cst_list_prim_u_8_strict {
14080 let ans = wire_cst_list_prim_u_8_strict {
14081 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14082 len,
14083 };
14084 flutter_rust_bridge::for_generated::new_leak_box_ptr(ans)
14085 }
14086
14087 #[unsafe(no_mangle)]
14088 pub extern "C" fn frbgen_breez_liquid_cst_new_list_rate(len: i32) -> *mut wire_cst_list_rate {
14089 let wrap = wire_cst_list_rate {
14090 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14091 <wire_cst_rate>::new_with_null_ptr(),
14092 len,
14093 ),
14094 len,
14095 };
14096 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14097 }
14098
14099 #[unsafe(no_mangle)]
14100 pub extern "C" fn frbgen_breez_liquid_cst_new_list_refundable_swap(
14101 len: i32,
14102 ) -> *mut wire_cst_list_refundable_swap {
14103 let wrap = wire_cst_list_refundable_swap {
14104 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14105 <wire_cst_refundable_swap>::new_with_null_ptr(),
14106 len,
14107 ),
14108 len,
14109 };
14110 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14111 }
14112
14113 #[unsafe(no_mangle)]
14114 pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint(
14115 len: i32,
14116 ) -> *mut wire_cst_list_route_hint {
14117 let wrap = wire_cst_list_route_hint {
14118 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14119 <wire_cst_route_hint>::new_with_null_ptr(),
14120 len,
14121 ),
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_route_hint_hop(
14129 len: i32,
14130 ) -> *mut wire_cst_list_route_hint_hop {
14131 let wrap = wire_cst_list_route_hint_hop {
14132 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14133 <wire_cst_route_hint_hop>::new_with_null_ptr(),
14134 len,
14135 ),
14136 len,
14137 };
14138 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14139 }
14140
14141 #[repr(C)]
14142 #[derive(Clone, Copy)]
14143 pub struct wire_cst_accept_payment_proposed_fees_request {
14144 response: wire_cst_fetch_payment_proposed_fees_response,
14145 }
14146 #[repr(C)]
14147 #[derive(Clone, Copy)]
14148 pub struct wire_cst_aes_success_action_data {
14149 description: *mut wire_cst_list_prim_u_8_strict,
14150 ciphertext: *mut wire_cst_list_prim_u_8_strict,
14151 iv: *mut wire_cst_list_prim_u_8_strict,
14152 }
14153 #[repr(C)]
14154 #[derive(Clone, Copy)]
14155 pub struct wire_cst_aes_success_action_data_decrypted {
14156 description: *mut wire_cst_list_prim_u_8_strict,
14157 plaintext: *mut wire_cst_list_prim_u_8_strict,
14158 }
14159 #[repr(C)]
14160 #[derive(Clone, Copy)]
14161 pub struct wire_cst_aes_success_action_data_result {
14162 tag: i32,
14163 kind: AesSuccessActionDataResultKind,
14164 }
14165 #[repr(C)]
14166 #[derive(Clone, Copy)]
14167 pub union AesSuccessActionDataResultKind {
14168 Decrypted: wire_cst_AesSuccessActionDataResult_Decrypted,
14169 ErrorStatus: wire_cst_AesSuccessActionDataResult_ErrorStatus,
14170 nil__: (),
14171 }
14172 #[repr(C)]
14173 #[derive(Clone, Copy)]
14174 pub struct wire_cst_AesSuccessActionDataResult_Decrypted {
14175 data: *mut wire_cst_aes_success_action_data_decrypted,
14176 }
14177 #[repr(C)]
14178 #[derive(Clone, Copy)]
14179 pub struct wire_cst_AesSuccessActionDataResult_ErrorStatus {
14180 reason: *mut wire_cst_list_prim_u_8_strict,
14181 }
14182 #[repr(C)]
14183 #[derive(Clone, Copy)]
14184 pub struct wire_cst_amount {
14185 tag: i32,
14186 kind: AmountKind,
14187 }
14188 #[repr(C)]
14189 #[derive(Clone, Copy)]
14190 pub union AmountKind {
14191 Bitcoin: wire_cst_Amount_Bitcoin,
14192 Currency: wire_cst_Amount_Currency,
14193 nil__: (),
14194 }
14195 #[repr(C)]
14196 #[derive(Clone, Copy)]
14197 pub struct wire_cst_Amount_Bitcoin {
14198 amount_msat: u64,
14199 }
14200 #[repr(C)]
14201 #[derive(Clone, Copy)]
14202 pub struct wire_cst_Amount_Currency {
14203 iso4217_code: *mut wire_cst_list_prim_u_8_strict,
14204 fractional_amount: u64,
14205 }
14206 #[repr(C)]
14207 #[derive(Clone, Copy)]
14208 pub struct wire_cst_asset_balance {
14209 asset_id: *mut wire_cst_list_prim_u_8_strict,
14210 balance_sat: u64,
14211 name: *mut wire_cst_list_prim_u_8_strict,
14212 ticker: *mut wire_cst_list_prim_u_8_strict,
14213 balance: *mut f64,
14214 }
14215 #[repr(C)]
14216 #[derive(Clone, Copy)]
14217 pub struct wire_cst_asset_info {
14218 name: *mut wire_cst_list_prim_u_8_strict,
14219 ticker: *mut wire_cst_list_prim_u_8_strict,
14220 amount: f64,
14221 fees: *mut f64,
14222 }
14223 #[repr(C)]
14224 #[derive(Clone, Copy)]
14225 pub struct wire_cst_asset_metadata {
14226 asset_id: *mut wire_cst_list_prim_u_8_strict,
14227 name: *mut wire_cst_list_prim_u_8_strict,
14228 ticker: *mut wire_cst_list_prim_u_8_strict,
14229 precision: u8,
14230 fiat_id: *mut wire_cst_list_prim_u_8_strict,
14231 }
14232 #[repr(C)]
14233 #[derive(Clone, Copy)]
14234 pub struct wire_cst_backup_request {
14235 backup_path: *mut wire_cst_list_prim_u_8_strict,
14236 }
14237 #[repr(C)]
14238 #[derive(Clone, Copy)]
14239 pub struct wire_cst_binding_event_listener {
14240 stream: *mut wire_cst_list_prim_u_8_strict,
14241 }
14242 #[repr(C)]
14243 #[derive(Clone, Copy)]
14244 pub struct wire_cst_bitcoin_address_data {
14245 address: *mut wire_cst_list_prim_u_8_strict,
14246 network: i32,
14247 amount_sat: *mut u64,
14248 label: *mut wire_cst_list_prim_u_8_strict,
14249 message: *mut wire_cst_list_prim_u_8_strict,
14250 }
14251 #[repr(C)]
14252 #[derive(Clone, Copy)]
14253 pub struct wire_cst_blockchain_explorer {
14254 tag: i32,
14255 kind: BlockchainExplorerKind,
14256 }
14257 #[repr(C)]
14258 #[derive(Clone, Copy)]
14259 pub union BlockchainExplorerKind {
14260 Electrum: wire_cst_BlockchainExplorer_Electrum,
14261 Esplora: wire_cst_BlockchainExplorer_Esplora,
14262 nil__: (),
14263 }
14264 #[repr(C)]
14265 #[derive(Clone, Copy)]
14266 pub struct wire_cst_BlockchainExplorer_Electrum {
14267 url: *mut wire_cst_list_prim_u_8_strict,
14268 }
14269 #[repr(C)]
14270 #[derive(Clone, Copy)]
14271 pub struct wire_cst_BlockchainExplorer_Esplora {
14272 url: *mut wire_cst_list_prim_u_8_strict,
14273 use_waterfalls: bool,
14274 }
14275 #[repr(C)]
14276 #[derive(Clone, Copy)]
14277 pub struct wire_cst_blockchain_info {
14278 liquid_tip: u32,
14279 bitcoin_tip: u32,
14280 }
14281 #[repr(C)]
14282 #[derive(Clone, Copy)]
14283 pub struct wire_cst_buy_bitcoin_request {
14284 prepare_response: wire_cst_prepare_buy_bitcoin_response,
14285 redirect_url: *mut wire_cst_list_prim_u_8_strict,
14286 }
14287 #[repr(C)]
14288 #[derive(Clone, Copy)]
14289 pub struct wire_cst_check_message_request {
14290 message: *mut wire_cst_list_prim_u_8_strict,
14291 pubkey: *mut wire_cst_list_prim_u_8_strict,
14292 signature: *mut wire_cst_list_prim_u_8_strict,
14293 }
14294 #[repr(C)]
14295 #[derive(Clone, Copy)]
14296 pub struct wire_cst_check_message_response {
14297 is_valid: bool,
14298 }
14299 #[repr(C)]
14300 #[derive(Clone, Copy)]
14301 pub struct wire_cst_config {
14302 liquid_explorer: wire_cst_blockchain_explorer,
14303 bitcoin_explorer: wire_cst_blockchain_explorer,
14304 working_dir: *mut wire_cst_list_prim_u_8_strict,
14305 cache_dir: *mut wire_cst_list_prim_u_8_strict,
14306 network: i32,
14307 payment_timeout_sec: u64,
14308 sync_service_url: *mut wire_cst_list_prim_u_8_strict,
14309 zero_conf_max_amount_sat: *mut u64,
14310 breez_api_key: *mut wire_cst_list_prim_u_8_strict,
14311 external_input_parsers: *mut wire_cst_list_external_input_parser,
14312 use_default_external_input_parsers: bool,
14313 onchain_fee_rate_leeway_sat_per_vbyte: *mut u32,
14314 asset_metadata: *mut wire_cst_list_asset_metadata,
14315 sideswap_api_key: *mut wire_cst_list_prim_u_8_strict,
14316 }
14317 #[repr(C)]
14318 #[derive(Clone, Copy)]
14319 pub struct wire_cst_connect_request {
14320 config: wire_cst_config,
14321 mnemonic: *mut wire_cst_list_prim_u_8_strict,
14322 passphrase: *mut wire_cst_list_prim_u_8_strict,
14323 seed: *mut wire_cst_list_prim_u_8_strict,
14324 }
14325 #[repr(C)]
14326 #[derive(Clone, Copy)]
14327 pub struct wire_cst_create_bolt_12_invoice_request {
14328 offer: *mut wire_cst_list_prim_u_8_strict,
14329 invoice_request: *mut wire_cst_list_prim_u_8_strict,
14330 }
14331 #[repr(C)]
14332 #[derive(Clone, Copy)]
14333 pub struct wire_cst_create_bolt_12_invoice_response {
14334 invoice: *mut wire_cst_list_prim_u_8_strict,
14335 }
14336 #[repr(C)]
14337 #[derive(Clone, Copy)]
14338 pub struct wire_cst_currency_info {
14339 name: *mut wire_cst_list_prim_u_8_strict,
14340 fraction_size: u32,
14341 spacing: *mut u32,
14342 symbol: *mut wire_cst_symbol,
14343 uniq_symbol: *mut wire_cst_symbol,
14344 localized_name: *mut wire_cst_list_localized_name,
14345 locale_overrides: *mut wire_cst_list_locale_overrides,
14346 }
14347 #[repr(C)]
14348 #[derive(Clone, Copy)]
14349 pub struct wire_cst_external_input_parser {
14350 provider_id: *mut wire_cst_list_prim_u_8_strict,
14351 input_regex: *mut wire_cst_list_prim_u_8_strict,
14352 parser_url: *mut wire_cst_list_prim_u_8_strict,
14353 }
14354 #[repr(C)]
14355 #[derive(Clone, Copy)]
14356 pub struct wire_cst_fetch_payment_proposed_fees_request {
14357 swap_id: *mut wire_cst_list_prim_u_8_strict,
14358 }
14359 #[repr(C)]
14360 #[derive(Clone, Copy)]
14361 pub struct wire_cst_fetch_payment_proposed_fees_response {
14362 swap_id: *mut wire_cst_list_prim_u_8_strict,
14363 fees_sat: u64,
14364 payer_amount_sat: u64,
14365 receiver_amount_sat: u64,
14366 }
14367 #[repr(C)]
14368 #[derive(Clone, Copy)]
14369 pub struct wire_cst_fiat_currency {
14370 id: *mut wire_cst_list_prim_u_8_strict,
14371 info: wire_cst_currency_info,
14372 }
14373 #[repr(C)]
14374 #[derive(Clone, Copy)]
14375 pub struct wire_cst_get_info_response {
14376 wallet_info: wire_cst_wallet_info,
14377 blockchain_info: wire_cst_blockchain_info,
14378 }
14379 #[repr(C)]
14380 #[derive(Clone, Copy)]
14381 pub struct wire_cst_get_payment_request {
14382 tag: i32,
14383 kind: GetPaymentRequestKind,
14384 }
14385 #[repr(C)]
14386 #[derive(Clone, Copy)]
14387 pub union GetPaymentRequestKind {
14388 PaymentHash: wire_cst_GetPaymentRequest_PaymentHash,
14389 SwapId: wire_cst_GetPaymentRequest_SwapId,
14390 nil__: (),
14391 }
14392 #[repr(C)]
14393 #[derive(Clone, Copy)]
14394 pub struct wire_cst_GetPaymentRequest_PaymentHash {
14395 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14396 }
14397 #[repr(C)]
14398 #[derive(Clone, Copy)]
14399 pub struct wire_cst_GetPaymentRequest_SwapId {
14400 swap_id: *mut wire_cst_list_prim_u_8_strict,
14401 }
14402 #[repr(C)]
14403 #[derive(Clone, Copy)]
14404 pub struct wire_cst_input_type {
14405 tag: i32,
14406 kind: InputTypeKind,
14407 }
14408 #[repr(C)]
14409 #[derive(Clone, Copy)]
14410 pub union InputTypeKind {
14411 BitcoinAddress: wire_cst_InputType_BitcoinAddress,
14412 LiquidAddress: wire_cst_InputType_LiquidAddress,
14413 Bolt11: wire_cst_InputType_Bolt11,
14414 Bolt12Offer: wire_cst_InputType_Bolt12Offer,
14415 NodeId: wire_cst_InputType_NodeId,
14416 Url: wire_cst_InputType_Url,
14417 LnUrlPay: wire_cst_InputType_LnUrlPay,
14418 LnUrlWithdraw: wire_cst_InputType_LnUrlWithdraw,
14419 LnUrlAuth: wire_cst_InputType_LnUrlAuth,
14420 LnUrlError: wire_cst_InputType_LnUrlError,
14421 nil__: (),
14422 }
14423 #[repr(C)]
14424 #[derive(Clone, Copy)]
14425 pub struct wire_cst_InputType_BitcoinAddress {
14426 address: *mut wire_cst_bitcoin_address_data,
14427 }
14428 #[repr(C)]
14429 #[derive(Clone, Copy)]
14430 pub struct wire_cst_InputType_LiquidAddress {
14431 address: *mut wire_cst_liquid_address_data,
14432 }
14433 #[repr(C)]
14434 #[derive(Clone, Copy)]
14435 pub struct wire_cst_InputType_Bolt11 {
14436 invoice: *mut wire_cst_ln_invoice,
14437 }
14438 #[repr(C)]
14439 #[derive(Clone, Copy)]
14440 pub struct wire_cst_InputType_Bolt12Offer {
14441 offer: *mut wire_cst_ln_offer,
14442 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14443 }
14444 #[repr(C)]
14445 #[derive(Clone, Copy)]
14446 pub struct wire_cst_InputType_NodeId {
14447 node_id: *mut wire_cst_list_prim_u_8_strict,
14448 }
14449 #[repr(C)]
14450 #[derive(Clone, Copy)]
14451 pub struct wire_cst_InputType_Url {
14452 url: *mut wire_cst_list_prim_u_8_strict,
14453 }
14454 #[repr(C)]
14455 #[derive(Clone, Copy)]
14456 pub struct wire_cst_InputType_LnUrlPay {
14457 data: *mut wire_cst_ln_url_pay_request_data,
14458 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14459 }
14460 #[repr(C)]
14461 #[derive(Clone, Copy)]
14462 pub struct wire_cst_InputType_LnUrlWithdraw {
14463 data: *mut wire_cst_ln_url_withdraw_request_data,
14464 }
14465 #[repr(C)]
14466 #[derive(Clone, Copy)]
14467 pub struct wire_cst_InputType_LnUrlAuth {
14468 data: *mut wire_cst_ln_url_auth_request_data,
14469 }
14470 #[repr(C)]
14471 #[derive(Clone, Copy)]
14472 pub struct wire_cst_InputType_LnUrlError {
14473 data: *mut wire_cst_ln_url_error_data,
14474 }
14475 #[repr(C)]
14476 #[derive(Clone, Copy)]
14477 pub struct wire_cst_lightning_payment_limits_response {
14478 send: wire_cst_limits,
14479 receive: wire_cst_limits,
14480 }
14481 #[repr(C)]
14482 #[derive(Clone, Copy)]
14483 pub struct wire_cst_limits {
14484 min_sat: u64,
14485 max_sat: u64,
14486 max_zero_conf_sat: u64,
14487 }
14488 #[repr(C)]
14489 #[derive(Clone, Copy)]
14490 pub struct wire_cst_liquid_address_data {
14491 address: *mut wire_cst_list_prim_u_8_strict,
14492 network: i32,
14493 asset_id: *mut wire_cst_list_prim_u_8_strict,
14494 amount: *mut f64,
14495 amount_sat: *mut u64,
14496 label: *mut wire_cst_list_prim_u_8_strict,
14497 message: *mut wire_cst_list_prim_u_8_strict,
14498 }
14499 #[repr(C)]
14500 #[derive(Clone, Copy)]
14501 pub struct wire_cst_list_String {
14502 ptr: *mut *mut wire_cst_list_prim_u_8_strict,
14503 len: i32,
14504 }
14505 #[repr(C)]
14506 #[derive(Clone, Copy)]
14507 pub struct wire_cst_list_asset_balance {
14508 ptr: *mut wire_cst_asset_balance,
14509 len: i32,
14510 }
14511 #[repr(C)]
14512 #[derive(Clone, Copy)]
14513 pub struct wire_cst_list_asset_metadata {
14514 ptr: *mut wire_cst_asset_metadata,
14515 len: i32,
14516 }
14517 #[repr(C)]
14518 #[derive(Clone, Copy)]
14519 pub struct wire_cst_list_external_input_parser {
14520 ptr: *mut wire_cst_external_input_parser,
14521 len: i32,
14522 }
14523 #[repr(C)]
14524 #[derive(Clone, Copy)]
14525 pub struct wire_cst_list_fiat_currency {
14526 ptr: *mut wire_cst_fiat_currency,
14527 len: i32,
14528 }
14529 #[repr(C)]
14530 #[derive(Clone, Copy)]
14531 pub struct wire_cst_list_ln_offer_blinded_path {
14532 ptr: *mut wire_cst_ln_offer_blinded_path,
14533 len: i32,
14534 }
14535 #[repr(C)]
14536 #[derive(Clone, Copy)]
14537 pub struct wire_cst_list_locale_overrides {
14538 ptr: *mut wire_cst_locale_overrides,
14539 len: i32,
14540 }
14541 #[repr(C)]
14542 #[derive(Clone, Copy)]
14543 pub struct wire_cst_list_localized_name {
14544 ptr: *mut wire_cst_localized_name,
14545 len: i32,
14546 }
14547 #[repr(C)]
14548 #[derive(Clone, Copy)]
14549 pub struct wire_cst_list_payment {
14550 ptr: *mut wire_cst_payment,
14551 len: i32,
14552 }
14553 #[repr(C)]
14554 #[derive(Clone, Copy)]
14555 pub struct wire_cst_list_payment_details {
14556 tag: i32,
14557 kind: ListPaymentDetailsKind,
14558 }
14559 #[repr(C)]
14560 #[derive(Clone, Copy)]
14561 pub union ListPaymentDetailsKind {
14562 Liquid: wire_cst_ListPaymentDetails_Liquid,
14563 Bitcoin: wire_cst_ListPaymentDetails_Bitcoin,
14564 nil__: (),
14565 }
14566 #[repr(C)]
14567 #[derive(Clone, Copy)]
14568 pub struct wire_cst_ListPaymentDetails_Liquid {
14569 asset_id: *mut wire_cst_list_prim_u_8_strict,
14570 destination: *mut wire_cst_list_prim_u_8_strict,
14571 }
14572 #[repr(C)]
14573 #[derive(Clone, Copy)]
14574 pub struct wire_cst_ListPaymentDetails_Bitcoin {
14575 address: *mut wire_cst_list_prim_u_8_strict,
14576 }
14577 #[repr(C)]
14578 #[derive(Clone, Copy)]
14579 pub struct wire_cst_list_payment_state {
14580 ptr: *mut i32,
14581 len: i32,
14582 }
14583 #[repr(C)]
14584 #[derive(Clone, Copy)]
14585 pub struct wire_cst_list_payment_type {
14586 ptr: *mut i32,
14587 len: i32,
14588 }
14589 #[repr(C)]
14590 #[derive(Clone, Copy)]
14591 pub struct wire_cst_list_payments_request {
14592 filters: *mut wire_cst_list_payment_type,
14593 states: *mut wire_cst_list_payment_state,
14594 from_timestamp: *mut i64,
14595 to_timestamp: *mut i64,
14596 offset: *mut u32,
14597 limit: *mut u32,
14598 details: *mut wire_cst_list_payment_details,
14599 sort_ascending: *mut bool,
14600 }
14601 #[repr(C)]
14602 #[derive(Clone, Copy)]
14603 pub struct wire_cst_list_prim_u_8_strict {
14604 ptr: *mut u8,
14605 len: i32,
14606 }
14607 #[repr(C)]
14608 #[derive(Clone, Copy)]
14609 pub struct wire_cst_list_rate {
14610 ptr: *mut wire_cst_rate,
14611 len: i32,
14612 }
14613 #[repr(C)]
14614 #[derive(Clone, Copy)]
14615 pub struct wire_cst_list_refundable_swap {
14616 ptr: *mut wire_cst_refundable_swap,
14617 len: i32,
14618 }
14619 #[repr(C)]
14620 #[derive(Clone, Copy)]
14621 pub struct wire_cst_list_route_hint {
14622 ptr: *mut wire_cst_route_hint,
14623 len: i32,
14624 }
14625 #[repr(C)]
14626 #[derive(Clone, Copy)]
14627 pub struct wire_cst_list_route_hint_hop {
14628 ptr: *mut wire_cst_route_hint_hop,
14629 len: i32,
14630 }
14631 #[repr(C)]
14632 #[derive(Clone, Copy)]
14633 pub struct wire_cst_ln_invoice {
14634 bolt11: *mut wire_cst_list_prim_u_8_strict,
14635 network: i32,
14636 payee_pubkey: *mut wire_cst_list_prim_u_8_strict,
14637 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14638 description: *mut wire_cst_list_prim_u_8_strict,
14639 description_hash: *mut wire_cst_list_prim_u_8_strict,
14640 amount_msat: *mut u64,
14641 timestamp: u64,
14642 expiry: u64,
14643 routing_hints: *mut wire_cst_list_route_hint,
14644 payment_secret: *mut wire_cst_list_prim_u_8_strict,
14645 min_final_cltv_expiry_delta: u64,
14646 }
14647 #[repr(C)]
14648 #[derive(Clone, Copy)]
14649 pub struct wire_cst_ln_offer {
14650 offer: *mut wire_cst_list_prim_u_8_strict,
14651 chains: *mut wire_cst_list_String,
14652 min_amount: *mut wire_cst_amount,
14653 description: *mut wire_cst_list_prim_u_8_strict,
14654 absolute_expiry: *mut u64,
14655 issuer: *mut wire_cst_list_prim_u_8_strict,
14656 signing_pubkey: *mut wire_cst_list_prim_u_8_strict,
14657 paths: *mut wire_cst_list_ln_offer_blinded_path,
14658 }
14659 #[repr(C)]
14660 #[derive(Clone, Copy)]
14661 pub struct wire_cst_ln_offer_blinded_path {
14662 blinded_hops: *mut wire_cst_list_String,
14663 }
14664 #[repr(C)]
14665 #[derive(Clone, Copy)]
14666 pub struct wire_cst_ln_url_auth_error {
14667 tag: i32,
14668 kind: LnUrlAuthErrorKind,
14669 }
14670 #[repr(C)]
14671 #[derive(Clone, Copy)]
14672 pub union LnUrlAuthErrorKind {
14673 Generic: wire_cst_LnUrlAuthError_Generic,
14674 InvalidUri: wire_cst_LnUrlAuthError_InvalidUri,
14675 ServiceConnectivity: wire_cst_LnUrlAuthError_ServiceConnectivity,
14676 nil__: (),
14677 }
14678 #[repr(C)]
14679 #[derive(Clone, Copy)]
14680 pub struct wire_cst_LnUrlAuthError_Generic {
14681 err: *mut wire_cst_list_prim_u_8_strict,
14682 }
14683 #[repr(C)]
14684 #[derive(Clone, Copy)]
14685 pub struct wire_cst_LnUrlAuthError_InvalidUri {
14686 err: *mut wire_cst_list_prim_u_8_strict,
14687 }
14688 #[repr(C)]
14689 #[derive(Clone, Copy)]
14690 pub struct wire_cst_LnUrlAuthError_ServiceConnectivity {
14691 err: *mut wire_cst_list_prim_u_8_strict,
14692 }
14693 #[repr(C)]
14694 #[derive(Clone, Copy)]
14695 pub struct wire_cst_ln_url_auth_request_data {
14696 k1: *mut wire_cst_list_prim_u_8_strict,
14697 action: *mut wire_cst_list_prim_u_8_strict,
14698 domain: *mut wire_cst_list_prim_u_8_strict,
14699 url: *mut wire_cst_list_prim_u_8_strict,
14700 }
14701 #[repr(C)]
14702 #[derive(Clone, Copy)]
14703 pub struct wire_cst_ln_url_callback_status {
14704 tag: i32,
14705 kind: LnUrlCallbackStatusKind,
14706 }
14707 #[repr(C)]
14708 #[derive(Clone, Copy)]
14709 pub union LnUrlCallbackStatusKind {
14710 ErrorStatus: wire_cst_LnUrlCallbackStatus_ErrorStatus,
14711 nil__: (),
14712 }
14713 #[repr(C)]
14714 #[derive(Clone, Copy)]
14715 pub struct wire_cst_LnUrlCallbackStatus_ErrorStatus {
14716 data: *mut wire_cst_ln_url_error_data,
14717 }
14718 #[repr(C)]
14719 #[derive(Clone, Copy)]
14720 pub struct wire_cst_ln_url_error_data {
14721 reason: *mut wire_cst_list_prim_u_8_strict,
14722 }
14723 #[repr(C)]
14724 #[derive(Clone, Copy)]
14725 pub struct wire_cst_ln_url_info {
14726 ln_address: *mut wire_cst_list_prim_u_8_strict,
14727 lnurl_pay_comment: *mut wire_cst_list_prim_u_8_strict,
14728 lnurl_pay_domain: *mut wire_cst_list_prim_u_8_strict,
14729 lnurl_pay_metadata: *mut wire_cst_list_prim_u_8_strict,
14730 lnurl_pay_success_action: *mut wire_cst_success_action_processed,
14731 lnurl_pay_unprocessed_success_action: *mut wire_cst_success_action,
14732 lnurl_withdraw_endpoint: *mut wire_cst_list_prim_u_8_strict,
14733 }
14734 #[repr(C)]
14735 #[derive(Clone, Copy)]
14736 pub struct wire_cst_ln_url_pay_error {
14737 tag: i32,
14738 kind: LnUrlPayErrorKind,
14739 }
14740 #[repr(C)]
14741 #[derive(Clone, Copy)]
14742 pub union LnUrlPayErrorKind {
14743 Generic: wire_cst_LnUrlPayError_Generic,
14744 InsufficientBalance: wire_cst_LnUrlPayError_InsufficientBalance,
14745 InvalidAmount: wire_cst_LnUrlPayError_InvalidAmount,
14746 InvalidInvoice: wire_cst_LnUrlPayError_InvalidInvoice,
14747 InvalidNetwork: wire_cst_LnUrlPayError_InvalidNetwork,
14748 InvalidUri: wire_cst_LnUrlPayError_InvalidUri,
14749 InvoiceExpired: wire_cst_LnUrlPayError_InvoiceExpired,
14750 PaymentFailed: wire_cst_LnUrlPayError_PaymentFailed,
14751 PaymentTimeout: wire_cst_LnUrlPayError_PaymentTimeout,
14752 RouteNotFound: wire_cst_LnUrlPayError_RouteNotFound,
14753 RouteTooExpensive: wire_cst_LnUrlPayError_RouteTooExpensive,
14754 ServiceConnectivity: wire_cst_LnUrlPayError_ServiceConnectivity,
14755 nil__: (),
14756 }
14757 #[repr(C)]
14758 #[derive(Clone, Copy)]
14759 pub struct wire_cst_LnUrlPayError_Generic {
14760 err: *mut wire_cst_list_prim_u_8_strict,
14761 }
14762 #[repr(C)]
14763 #[derive(Clone, Copy)]
14764 pub struct wire_cst_LnUrlPayError_InsufficientBalance {
14765 err: *mut wire_cst_list_prim_u_8_strict,
14766 }
14767 #[repr(C)]
14768 #[derive(Clone, Copy)]
14769 pub struct wire_cst_LnUrlPayError_InvalidAmount {
14770 err: *mut wire_cst_list_prim_u_8_strict,
14771 }
14772 #[repr(C)]
14773 #[derive(Clone, Copy)]
14774 pub struct wire_cst_LnUrlPayError_InvalidInvoice {
14775 err: *mut wire_cst_list_prim_u_8_strict,
14776 }
14777 #[repr(C)]
14778 #[derive(Clone, Copy)]
14779 pub struct wire_cst_LnUrlPayError_InvalidNetwork {
14780 err: *mut wire_cst_list_prim_u_8_strict,
14781 }
14782 #[repr(C)]
14783 #[derive(Clone, Copy)]
14784 pub struct wire_cst_LnUrlPayError_InvalidUri {
14785 err: *mut wire_cst_list_prim_u_8_strict,
14786 }
14787 #[repr(C)]
14788 #[derive(Clone, Copy)]
14789 pub struct wire_cst_LnUrlPayError_InvoiceExpired {
14790 err: *mut wire_cst_list_prim_u_8_strict,
14791 }
14792 #[repr(C)]
14793 #[derive(Clone, Copy)]
14794 pub struct wire_cst_LnUrlPayError_PaymentFailed {
14795 err: *mut wire_cst_list_prim_u_8_strict,
14796 }
14797 #[repr(C)]
14798 #[derive(Clone, Copy)]
14799 pub struct wire_cst_LnUrlPayError_PaymentTimeout {
14800 err: *mut wire_cst_list_prim_u_8_strict,
14801 }
14802 #[repr(C)]
14803 #[derive(Clone, Copy)]
14804 pub struct wire_cst_LnUrlPayError_RouteNotFound {
14805 err: *mut wire_cst_list_prim_u_8_strict,
14806 }
14807 #[repr(C)]
14808 #[derive(Clone, Copy)]
14809 pub struct wire_cst_LnUrlPayError_RouteTooExpensive {
14810 err: *mut wire_cst_list_prim_u_8_strict,
14811 }
14812 #[repr(C)]
14813 #[derive(Clone, Copy)]
14814 pub struct wire_cst_LnUrlPayError_ServiceConnectivity {
14815 err: *mut wire_cst_list_prim_u_8_strict,
14816 }
14817 #[repr(C)]
14818 #[derive(Clone, Copy)]
14819 pub struct wire_cst_ln_url_pay_error_data {
14820 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14821 reason: *mut wire_cst_list_prim_u_8_strict,
14822 }
14823 #[repr(C)]
14824 #[derive(Clone, Copy)]
14825 pub struct wire_cst_ln_url_pay_request {
14826 prepare_response: wire_cst_prepare_ln_url_pay_response,
14827 }
14828 #[repr(C)]
14829 #[derive(Clone, Copy)]
14830 pub struct wire_cst_ln_url_pay_request_data {
14831 callback: *mut wire_cst_list_prim_u_8_strict,
14832 min_sendable: u64,
14833 max_sendable: u64,
14834 metadata_str: *mut wire_cst_list_prim_u_8_strict,
14835 comment_allowed: u16,
14836 domain: *mut wire_cst_list_prim_u_8_strict,
14837 allows_nostr: bool,
14838 nostr_pubkey: *mut wire_cst_list_prim_u_8_strict,
14839 ln_address: *mut wire_cst_list_prim_u_8_strict,
14840 }
14841 #[repr(C)]
14842 #[derive(Clone, Copy)]
14843 pub struct wire_cst_ln_url_pay_result {
14844 tag: i32,
14845 kind: LnUrlPayResultKind,
14846 }
14847 #[repr(C)]
14848 #[derive(Clone, Copy)]
14849 pub union LnUrlPayResultKind {
14850 EndpointSuccess: wire_cst_LnUrlPayResult_EndpointSuccess,
14851 EndpointError: wire_cst_LnUrlPayResult_EndpointError,
14852 PayError: wire_cst_LnUrlPayResult_PayError,
14853 nil__: (),
14854 }
14855 #[repr(C)]
14856 #[derive(Clone, Copy)]
14857 pub struct wire_cst_LnUrlPayResult_EndpointSuccess {
14858 data: *mut wire_cst_ln_url_pay_success_data,
14859 }
14860 #[repr(C)]
14861 #[derive(Clone, Copy)]
14862 pub struct wire_cst_LnUrlPayResult_EndpointError {
14863 data: *mut wire_cst_ln_url_error_data,
14864 }
14865 #[repr(C)]
14866 #[derive(Clone, Copy)]
14867 pub struct wire_cst_LnUrlPayResult_PayError {
14868 data: *mut wire_cst_ln_url_pay_error_data,
14869 }
14870 #[repr(C)]
14871 #[derive(Clone, Copy)]
14872 pub struct wire_cst_ln_url_pay_success_data {
14873 payment: wire_cst_payment,
14874 success_action: *mut wire_cst_success_action_processed,
14875 }
14876 #[repr(C)]
14877 #[derive(Clone, Copy)]
14878 pub struct wire_cst_ln_url_withdraw_error {
14879 tag: i32,
14880 kind: LnUrlWithdrawErrorKind,
14881 }
14882 #[repr(C)]
14883 #[derive(Clone, Copy)]
14884 pub union LnUrlWithdrawErrorKind {
14885 Generic: wire_cst_LnUrlWithdrawError_Generic,
14886 InvalidAmount: wire_cst_LnUrlWithdrawError_InvalidAmount,
14887 InvalidInvoice: wire_cst_LnUrlWithdrawError_InvalidInvoice,
14888 InvalidUri: wire_cst_LnUrlWithdrawError_InvalidUri,
14889 InvoiceNoRoutingHints: wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints,
14890 ServiceConnectivity: wire_cst_LnUrlWithdrawError_ServiceConnectivity,
14891 nil__: (),
14892 }
14893 #[repr(C)]
14894 #[derive(Clone, Copy)]
14895 pub struct wire_cst_LnUrlWithdrawError_Generic {
14896 err: *mut wire_cst_list_prim_u_8_strict,
14897 }
14898 #[repr(C)]
14899 #[derive(Clone, Copy)]
14900 pub struct wire_cst_LnUrlWithdrawError_InvalidAmount {
14901 err: *mut wire_cst_list_prim_u_8_strict,
14902 }
14903 #[repr(C)]
14904 #[derive(Clone, Copy)]
14905 pub struct wire_cst_LnUrlWithdrawError_InvalidInvoice {
14906 err: *mut wire_cst_list_prim_u_8_strict,
14907 }
14908 #[repr(C)]
14909 #[derive(Clone, Copy)]
14910 pub struct wire_cst_LnUrlWithdrawError_InvalidUri {
14911 err: *mut wire_cst_list_prim_u_8_strict,
14912 }
14913 #[repr(C)]
14914 #[derive(Clone, Copy)]
14915 pub struct wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints {
14916 err: *mut wire_cst_list_prim_u_8_strict,
14917 }
14918 #[repr(C)]
14919 #[derive(Clone, Copy)]
14920 pub struct wire_cst_LnUrlWithdrawError_ServiceConnectivity {
14921 err: *mut wire_cst_list_prim_u_8_strict,
14922 }
14923 #[repr(C)]
14924 #[derive(Clone, Copy)]
14925 pub struct wire_cst_ln_url_withdraw_request {
14926 data: wire_cst_ln_url_withdraw_request_data,
14927 amount_msat: u64,
14928 description: *mut wire_cst_list_prim_u_8_strict,
14929 }
14930 #[repr(C)]
14931 #[derive(Clone, Copy)]
14932 pub struct wire_cst_ln_url_withdraw_request_data {
14933 callback: *mut wire_cst_list_prim_u_8_strict,
14934 k1: *mut wire_cst_list_prim_u_8_strict,
14935 default_description: *mut wire_cst_list_prim_u_8_strict,
14936 min_withdrawable: u64,
14937 max_withdrawable: u64,
14938 }
14939 #[repr(C)]
14940 #[derive(Clone, Copy)]
14941 pub struct wire_cst_ln_url_withdraw_result {
14942 tag: i32,
14943 kind: LnUrlWithdrawResultKind,
14944 }
14945 #[repr(C)]
14946 #[derive(Clone, Copy)]
14947 pub union LnUrlWithdrawResultKind {
14948 Ok: wire_cst_LnUrlWithdrawResult_Ok,
14949 Timeout: wire_cst_LnUrlWithdrawResult_Timeout,
14950 ErrorStatus: wire_cst_LnUrlWithdrawResult_ErrorStatus,
14951 nil__: (),
14952 }
14953 #[repr(C)]
14954 #[derive(Clone, Copy)]
14955 pub struct wire_cst_LnUrlWithdrawResult_Ok {
14956 data: *mut wire_cst_ln_url_withdraw_success_data,
14957 }
14958 #[repr(C)]
14959 #[derive(Clone, Copy)]
14960 pub struct wire_cst_LnUrlWithdrawResult_Timeout {
14961 data: *mut wire_cst_ln_url_withdraw_success_data,
14962 }
14963 #[repr(C)]
14964 #[derive(Clone, Copy)]
14965 pub struct wire_cst_LnUrlWithdrawResult_ErrorStatus {
14966 data: *mut wire_cst_ln_url_error_data,
14967 }
14968 #[repr(C)]
14969 #[derive(Clone, Copy)]
14970 pub struct wire_cst_ln_url_withdraw_success_data {
14971 invoice: wire_cst_ln_invoice,
14972 }
14973 #[repr(C)]
14974 #[derive(Clone, Copy)]
14975 pub struct wire_cst_locale_overrides {
14976 locale: *mut wire_cst_list_prim_u_8_strict,
14977 spacing: *mut u32,
14978 symbol: wire_cst_symbol,
14979 }
14980 #[repr(C)]
14981 #[derive(Clone, Copy)]
14982 pub struct wire_cst_localized_name {
14983 locale: *mut wire_cst_list_prim_u_8_strict,
14984 name: *mut wire_cst_list_prim_u_8_strict,
14985 }
14986 #[repr(C)]
14987 #[derive(Clone, Copy)]
14988 pub struct wire_cst_log_entry {
14989 line: *mut wire_cst_list_prim_u_8_strict,
14990 level: *mut wire_cst_list_prim_u_8_strict,
14991 }
14992 #[repr(C)]
14993 #[derive(Clone, Copy)]
14994 pub struct wire_cst_message_success_action_data {
14995 message: *mut wire_cst_list_prim_u_8_strict,
14996 }
14997 #[repr(C)]
14998 #[derive(Clone, Copy)]
14999 pub struct wire_cst_onchain_payment_limits_response {
15000 send: wire_cst_limits,
15001 receive: wire_cst_limits,
15002 }
15003 #[repr(C)]
15004 #[derive(Clone, Copy)]
15005 pub struct wire_cst_pay_amount {
15006 tag: i32,
15007 kind: PayAmountKind,
15008 }
15009 #[repr(C)]
15010 #[derive(Clone, Copy)]
15011 pub union PayAmountKind {
15012 Bitcoin: wire_cst_PayAmount_Bitcoin,
15013 Asset: wire_cst_PayAmount_Asset,
15014 nil__: (),
15015 }
15016 #[repr(C)]
15017 #[derive(Clone, Copy)]
15018 pub struct wire_cst_PayAmount_Bitcoin {
15019 receiver_amount_sat: u64,
15020 }
15021 #[repr(C)]
15022 #[derive(Clone, Copy)]
15023 pub struct wire_cst_PayAmount_Asset {
15024 asset_id: *mut wire_cst_list_prim_u_8_strict,
15025 receiver_amount: f64,
15026 estimate_asset_fees: *mut bool,
15027 }
15028 #[repr(C)]
15029 #[derive(Clone, Copy)]
15030 pub struct wire_cst_pay_onchain_request {
15031 address: *mut wire_cst_list_prim_u_8_strict,
15032 prepare_response: wire_cst_prepare_pay_onchain_response,
15033 }
15034 #[repr(C)]
15035 #[derive(Clone, Copy)]
15036 pub struct wire_cst_payment {
15037 destination: *mut wire_cst_list_prim_u_8_strict,
15038 tx_id: *mut wire_cst_list_prim_u_8_strict,
15039 unblinding_data: *mut wire_cst_list_prim_u_8_strict,
15040 timestamp: u32,
15041 amount_sat: u64,
15042 fees_sat: u64,
15043 swapper_fees_sat: *mut u64,
15044 payment_type: i32,
15045 status: i32,
15046 details: wire_cst_payment_details,
15047 }
15048 #[repr(C)]
15049 #[derive(Clone, Copy)]
15050 pub struct wire_cst_payment_details {
15051 tag: i32,
15052 kind: PaymentDetailsKind,
15053 }
15054 #[repr(C)]
15055 #[derive(Clone, Copy)]
15056 pub union PaymentDetailsKind {
15057 Lightning: wire_cst_PaymentDetails_Lightning,
15058 Liquid: wire_cst_PaymentDetails_Liquid,
15059 Bitcoin: wire_cst_PaymentDetails_Bitcoin,
15060 nil__: (),
15061 }
15062 #[repr(C)]
15063 #[derive(Clone, Copy)]
15064 pub struct wire_cst_PaymentDetails_Lightning {
15065 swap_id: *mut wire_cst_list_prim_u_8_strict,
15066 description: *mut wire_cst_list_prim_u_8_strict,
15067 liquid_expiration_blockheight: u32,
15068 preimage: *mut wire_cst_list_prim_u_8_strict,
15069 invoice: *mut wire_cst_list_prim_u_8_strict,
15070 bolt12_offer: *mut wire_cst_list_prim_u_8_strict,
15071 payment_hash: *mut wire_cst_list_prim_u_8_strict,
15072 destination_pubkey: *mut wire_cst_list_prim_u_8_strict,
15073 lnurl_info: *mut wire_cst_ln_url_info,
15074 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15075 claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15076 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15077 refund_tx_amount_sat: *mut u64,
15078 }
15079 #[repr(C)]
15080 #[derive(Clone, Copy)]
15081 pub struct wire_cst_PaymentDetails_Liquid {
15082 destination: *mut wire_cst_list_prim_u_8_strict,
15083 description: *mut wire_cst_list_prim_u_8_strict,
15084 asset_id: *mut wire_cst_list_prim_u_8_strict,
15085 asset_info: *mut wire_cst_asset_info,
15086 lnurl_info: *mut wire_cst_ln_url_info,
15087 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15088 }
15089 #[repr(C)]
15090 #[derive(Clone, Copy)]
15091 pub struct wire_cst_PaymentDetails_Bitcoin {
15092 swap_id: *mut wire_cst_list_prim_u_8_strict,
15093 description: *mut wire_cst_list_prim_u_8_strict,
15094 auto_accepted_fees: bool,
15095 liquid_expiration_blockheight: *mut u32,
15096 bitcoin_expiration_blockheight: *mut u32,
15097 claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15098 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15099 refund_tx_amount_sat: *mut u64,
15100 }
15101 #[repr(C)]
15102 #[derive(Clone, Copy)]
15103 pub struct wire_cst_payment_error {
15104 tag: i32,
15105 kind: PaymentErrorKind,
15106 }
15107 #[repr(C)]
15108 #[derive(Clone, Copy)]
15109 pub union PaymentErrorKind {
15110 AmountOutOfRange: wire_cst_PaymentError_AmountOutOfRange,
15111 AmountMissing: wire_cst_PaymentError_AmountMissing,
15112 AssetError: wire_cst_PaymentError_AssetError,
15113 InvalidNetwork: wire_cst_PaymentError_InvalidNetwork,
15114 Generic: wire_cst_PaymentError_Generic,
15115 InvalidDescription: wire_cst_PaymentError_InvalidDescription,
15116 InvalidInvoice: wire_cst_PaymentError_InvalidInvoice,
15117 ReceiveError: wire_cst_PaymentError_ReceiveError,
15118 Refunded: wire_cst_PaymentError_Refunded,
15119 SendError: wire_cst_PaymentError_SendError,
15120 SignerError: wire_cst_PaymentError_SignerError,
15121 nil__: (),
15122 }
15123 #[repr(C)]
15124 #[derive(Clone, Copy)]
15125 pub struct wire_cst_PaymentError_AmountOutOfRange {
15126 min: u64,
15127 max: u64,
15128 }
15129 #[repr(C)]
15130 #[derive(Clone, Copy)]
15131 pub struct wire_cst_PaymentError_AmountMissing {
15132 err: *mut wire_cst_list_prim_u_8_strict,
15133 }
15134 #[repr(C)]
15135 #[derive(Clone, Copy)]
15136 pub struct wire_cst_PaymentError_AssetError {
15137 err: *mut wire_cst_list_prim_u_8_strict,
15138 }
15139 #[repr(C)]
15140 #[derive(Clone, Copy)]
15141 pub struct wire_cst_PaymentError_InvalidNetwork {
15142 err: *mut wire_cst_list_prim_u_8_strict,
15143 }
15144 #[repr(C)]
15145 #[derive(Clone, Copy)]
15146 pub struct wire_cst_PaymentError_Generic {
15147 err: *mut wire_cst_list_prim_u_8_strict,
15148 }
15149 #[repr(C)]
15150 #[derive(Clone, Copy)]
15151 pub struct wire_cst_PaymentError_InvalidDescription {
15152 err: *mut wire_cst_list_prim_u_8_strict,
15153 }
15154 #[repr(C)]
15155 #[derive(Clone, Copy)]
15156 pub struct wire_cst_PaymentError_InvalidInvoice {
15157 err: *mut wire_cst_list_prim_u_8_strict,
15158 }
15159 #[repr(C)]
15160 #[derive(Clone, Copy)]
15161 pub struct wire_cst_PaymentError_ReceiveError {
15162 err: *mut wire_cst_list_prim_u_8_strict,
15163 }
15164 #[repr(C)]
15165 #[derive(Clone, Copy)]
15166 pub struct wire_cst_PaymentError_Refunded {
15167 err: *mut wire_cst_list_prim_u_8_strict,
15168 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15169 }
15170 #[repr(C)]
15171 #[derive(Clone, Copy)]
15172 pub struct wire_cst_PaymentError_SendError {
15173 err: *mut wire_cst_list_prim_u_8_strict,
15174 }
15175 #[repr(C)]
15176 #[derive(Clone, Copy)]
15177 pub struct wire_cst_PaymentError_SignerError {
15178 err: *mut wire_cst_list_prim_u_8_strict,
15179 }
15180 #[repr(C)]
15181 #[derive(Clone, Copy)]
15182 pub struct wire_cst_prepare_buy_bitcoin_request {
15183 provider: i32,
15184 amount_sat: u64,
15185 }
15186 #[repr(C)]
15187 #[derive(Clone, Copy)]
15188 pub struct wire_cst_prepare_buy_bitcoin_response {
15189 provider: i32,
15190 amount_sat: u64,
15191 fees_sat: u64,
15192 }
15193 #[repr(C)]
15194 #[derive(Clone, Copy)]
15195 pub struct wire_cst_prepare_ln_url_pay_request {
15196 data: wire_cst_ln_url_pay_request_data,
15197 amount: wire_cst_pay_amount,
15198 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15199 comment: *mut wire_cst_list_prim_u_8_strict,
15200 validate_success_action_url: *mut bool,
15201 }
15202 #[repr(C)]
15203 #[derive(Clone, Copy)]
15204 pub struct wire_cst_prepare_ln_url_pay_response {
15205 destination: wire_cst_send_destination,
15206 fees_sat: u64,
15207 data: wire_cst_ln_url_pay_request_data,
15208 comment: *mut wire_cst_list_prim_u_8_strict,
15209 success_action: *mut wire_cst_success_action,
15210 }
15211 #[repr(C)]
15212 #[derive(Clone, Copy)]
15213 pub struct wire_cst_prepare_pay_onchain_request {
15214 amount: wire_cst_pay_amount,
15215 fee_rate_sat_per_vbyte: *mut u32,
15216 }
15217 #[repr(C)]
15218 #[derive(Clone, Copy)]
15219 pub struct wire_cst_prepare_pay_onchain_response {
15220 receiver_amount_sat: u64,
15221 claim_fees_sat: u64,
15222 total_fees_sat: u64,
15223 }
15224 #[repr(C)]
15225 #[derive(Clone, Copy)]
15226 pub struct wire_cst_prepare_receive_request {
15227 payment_method: i32,
15228 amount: *mut wire_cst_receive_amount,
15229 }
15230 #[repr(C)]
15231 #[derive(Clone, Copy)]
15232 pub struct wire_cst_prepare_receive_response {
15233 payment_method: i32,
15234 fees_sat: u64,
15235 amount: *mut wire_cst_receive_amount,
15236 min_payer_amount_sat: *mut u64,
15237 max_payer_amount_sat: *mut u64,
15238 swapper_feerate: *mut f64,
15239 }
15240 #[repr(C)]
15241 #[derive(Clone, Copy)]
15242 pub struct wire_cst_prepare_refund_request {
15243 swap_address: *mut wire_cst_list_prim_u_8_strict,
15244 refund_address: *mut wire_cst_list_prim_u_8_strict,
15245 fee_rate_sat_per_vbyte: u32,
15246 }
15247 #[repr(C)]
15248 #[derive(Clone, Copy)]
15249 pub struct wire_cst_prepare_refund_response {
15250 tx_vsize: u32,
15251 tx_fee_sat: u64,
15252 last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15253 }
15254 #[repr(C)]
15255 #[derive(Clone, Copy)]
15256 pub struct wire_cst_prepare_send_request {
15257 destination: *mut wire_cst_list_prim_u_8_strict,
15258 amount: *mut wire_cst_pay_amount,
15259 }
15260 #[repr(C)]
15261 #[derive(Clone, Copy)]
15262 pub struct wire_cst_prepare_send_response {
15263 destination: wire_cst_send_destination,
15264 fees_sat: *mut u64,
15265 estimated_asset_fees: *mut f64,
15266 }
15267 #[repr(C)]
15268 #[derive(Clone, Copy)]
15269 pub struct wire_cst_rate {
15270 coin: *mut wire_cst_list_prim_u_8_strict,
15271 value: f64,
15272 }
15273 #[repr(C)]
15274 #[derive(Clone, Copy)]
15275 pub struct wire_cst_receive_amount {
15276 tag: i32,
15277 kind: ReceiveAmountKind,
15278 }
15279 #[repr(C)]
15280 #[derive(Clone, Copy)]
15281 pub union ReceiveAmountKind {
15282 Bitcoin: wire_cst_ReceiveAmount_Bitcoin,
15283 Asset: wire_cst_ReceiveAmount_Asset,
15284 nil__: (),
15285 }
15286 #[repr(C)]
15287 #[derive(Clone, Copy)]
15288 pub struct wire_cst_ReceiveAmount_Bitcoin {
15289 payer_amount_sat: u64,
15290 }
15291 #[repr(C)]
15292 #[derive(Clone, Copy)]
15293 pub struct wire_cst_ReceiveAmount_Asset {
15294 asset_id: *mut wire_cst_list_prim_u_8_strict,
15295 payer_amount: *mut f64,
15296 }
15297 #[repr(C)]
15298 #[derive(Clone, Copy)]
15299 pub struct wire_cst_receive_payment_request {
15300 prepare_response: wire_cst_prepare_receive_response,
15301 description: *mut wire_cst_list_prim_u_8_strict,
15302 use_description_hash: *mut bool,
15303 }
15304 #[repr(C)]
15305 #[derive(Clone, Copy)]
15306 pub struct wire_cst_receive_payment_response {
15307 destination: *mut wire_cst_list_prim_u_8_strict,
15308 }
15309 #[repr(C)]
15310 #[derive(Clone, Copy)]
15311 pub struct wire_cst_recommended_fees {
15312 fastest_fee: u64,
15313 half_hour_fee: u64,
15314 hour_fee: u64,
15315 economy_fee: u64,
15316 minimum_fee: u64,
15317 }
15318 #[repr(C)]
15319 #[derive(Clone, Copy)]
15320 pub struct wire_cst_refund_request {
15321 swap_address: *mut wire_cst_list_prim_u_8_strict,
15322 refund_address: *mut wire_cst_list_prim_u_8_strict,
15323 fee_rate_sat_per_vbyte: u32,
15324 }
15325 #[repr(C)]
15326 #[derive(Clone, Copy)]
15327 pub struct wire_cst_refund_response {
15328 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15329 }
15330 #[repr(C)]
15331 #[derive(Clone, Copy)]
15332 pub struct wire_cst_refundable_swap {
15333 swap_address: *mut wire_cst_list_prim_u_8_strict,
15334 timestamp: u32,
15335 amount_sat: u64,
15336 last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15337 }
15338 #[repr(C)]
15339 #[derive(Clone, Copy)]
15340 pub struct wire_cst_restore_request {
15341 backup_path: *mut wire_cst_list_prim_u_8_strict,
15342 }
15343 #[repr(C)]
15344 #[derive(Clone, Copy)]
15345 pub struct wire_cst_route_hint {
15346 hops: *mut wire_cst_list_route_hint_hop,
15347 }
15348 #[repr(C)]
15349 #[derive(Clone, Copy)]
15350 pub struct wire_cst_route_hint_hop {
15351 src_node_id: *mut wire_cst_list_prim_u_8_strict,
15352 short_channel_id: *mut wire_cst_list_prim_u_8_strict,
15353 fees_base_msat: u32,
15354 fees_proportional_millionths: u32,
15355 cltv_expiry_delta: u64,
15356 htlc_minimum_msat: *mut u64,
15357 htlc_maximum_msat: *mut u64,
15358 }
15359 #[repr(C)]
15360 #[derive(Clone, Copy)]
15361 pub struct wire_cst_sdk_error {
15362 tag: i32,
15363 kind: SdkErrorKind,
15364 }
15365 #[repr(C)]
15366 #[derive(Clone, Copy)]
15367 pub union SdkErrorKind {
15368 Generic: wire_cst_SdkError_Generic,
15369 ServiceConnectivity: wire_cst_SdkError_ServiceConnectivity,
15370 nil__: (),
15371 }
15372 #[repr(C)]
15373 #[derive(Clone, Copy)]
15374 pub struct wire_cst_SdkError_Generic {
15375 err: *mut wire_cst_list_prim_u_8_strict,
15376 }
15377 #[repr(C)]
15378 #[derive(Clone, Copy)]
15379 pub struct wire_cst_SdkError_ServiceConnectivity {
15380 err: *mut wire_cst_list_prim_u_8_strict,
15381 }
15382 #[repr(C)]
15383 #[derive(Clone, Copy)]
15384 pub struct wire_cst_sdk_event {
15385 tag: i32,
15386 kind: SdkEventKind,
15387 }
15388 #[repr(C)]
15389 #[derive(Clone, Copy)]
15390 pub union SdkEventKind {
15391 PaymentFailed: wire_cst_SdkEvent_PaymentFailed,
15392 PaymentPending: wire_cst_SdkEvent_PaymentPending,
15393 PaymentRefundable: wire_cst_SdkEvent_PaymentRefundable,
15394 PaymentRefunded: wire_cst_SdkEvent_PaymentRefunded,
15395 PaymentRefundPending: wire_cst_SdkEvent_PaymentRefundPending,
15396 PaymentSucceeded: wire_cst_SdkEvent_PaymentSucceeded,
15397 PaymentWaitingConfirmation: wire_cst_SdkEvent_PaymentWaitingConfirmation,
15398 PaymentWaitingFeeAcceptance: wire_cst_SdkEvent_PaymentWaitingFeeAcceptance,
15399 DataSynced: wire_cst_SdkEvent_DataSynced,
15400 nil__: (),
15401 }
15402 #[repr(C)]
15403 #[derive(Clone, Copy)]
15404 pub struct wire_cst_SdkEvent_PaymentFailed {
15405 details: *mut wire_cst_payment,
15406 }
15407 #[repr(C)]
15408 #[derive(Clone, Copy)]
15409 pub struct wire_cst_SdkEvent_PaymentPending {
15410 details: *mut wire_cst_payment,
15411 }
15412 #[repr(C)]
15413 #[derive(Clone, Copy)]
15414 pub struct wire_cst_SdkEvent_PaymentRefundable {
15415 details: *mut wire_cst_payment,
15416 }
15417 #[repr(C)]
15418 #[derive(Clone, Copy)]
15419 pub struct wire_cst_SdkEvent_PaymentRefunded {
15420 details: *mut wire_cst_payment,
15421 }
15422 #[repr(C)]
15423 #[derive(Clone, Copy)]
15424 pub struct wire_cst_SdkEvent_PaymentRefundPending {
15425 details: *mut wire_cst_payment,
15426 }
15427 #[repr(C)]
15428 #[derive(Clone, Copy)]
15429 pub struct wire_cst_SdkEvent_PaymentSucceeded {
15430 details: *mut wire_cst_payment,
15431 }
15432 #[repr(C)]
15433 #[derive(Clone, Copy)]
15434 pub struct wire_cst_SdkEvent_PaymentWaitingConfirmation {
15435 details: *mut wire_cst_payment,
15436 }
15437 #[repr(C)]
15438 #[derive(Clone, Copy)]
15439 pub struct wire_cst_SdkEvent_PaymentWaitingFeeAcceptance {
15440 details: *mut wire_cst_payment,
15441 }
15442 #[repr(C)]
15443 #[derive(Clone, Copy)]
15444 pub struct wire_cst_SdkEvent_DataSynced {
15445 did_pull_new_records: bool,
15446 }
15447 #[repr(C)]
15448 #[derive(Clone, Copy)]
15449 pub struct wire_cst_send_destination {
15450 tag: i32,
15451 kind: SendDestinationKind,
15452 }
15453 #[repr(C)]
15454 #[derive(Clone, Copy)]
15455 pub union SendDestinationKind {
15456 LiquidAddress: wire_cst_SendDestination_LiquidAddress,
15457 Bolt11: wire_cst_SendDestination_Bolt11,
15458 Bolt12: wire_cst_SendDestination_Bolt12,
15459 nil__: (),
15460 }
15461 #[repr(C)]
15462 #[derive(Clone, Copy)]
15463 pub struct wire_cst_SendDestination_LiquidAddress {
15464 address_data: *mut wire_cst_liquid_address_data,
15465 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15466 }
15467 #[repr(C)]
15468 #[derive(Clone, Copy)]
15469 pub struct wire_cst_SendDestination_Bolt11 {
15470 invoice: *mut wire_cst_ln_invoice,
15471 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15472 }
15473 #[repr(C)]
15474 #[derive(Clone, Copy)]
15475 pub struct wire_cst_SendDestination_Bolt12 {
15476 offer: *mut wire_cst_ln_offer,
15477 receiver_amount_sat: u64,
15478 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15479 }
15480 #[repr(C)]
15481 #[derive(Clone, Copy)]
15482 pub struct wire_cst_send_payment_request {
15483 prepare_response: wire_cst_prepare_send_response,
15484 use_asset_fees: *mut bool,
15485 }
15486 #[repr(C)]
15487 #[derive(Clone, Copy)]
15488 pub struct wire_cst_send_payment_response {
15489 payment: wire_cst_payment,
15490 }
15491 #[repr(C)]
15492 #[derive(Clone, Copy)]
15493 pub struct wire_cst_sign_message_request {
15494 message: *mut wire_cst_list_prim_u_8_strict,
15495 }
15496 #[repr(C)]
15497 #[derive(Clone, Copy)]
15498 pub struct wire_cst_sign_message_response {
15499 signature: *mut wire_cst_list_prim_u_8_strict,
15500 }
15501 #[repr(C)]
15502 #[derive(Clone, Copy)]
15503 pub struct wire_cst_success_action {
15504 tag: i32,
15505 kind: SuccessActionKind,
15506 }
15507 #[repr(C)]
15508 #[derive(Clone, Copy)]
15509 pub union SuccessActionKind {
15510 Aes: wire_cst_SuccessAction_Aes,
15511 Message: wire_cst_SuccessAction_Message,
15512 Url: wire_cst_SuccessAction_Url,
15513 nil__: (),
15514 }
15515 #[repr(C)]
15516 #[derive(Clone, Copy)]
15517 pub struct wire_cst_SuccessAction_Aes {
15518 data: *mut wire_cst_aes_success_action_data,
15519 }
15520 #[repr(C)]
15521 #[derive(Clone, Copy)]
15522 pub struct wire_cst_SuccessAction_Message {
15523 data: *mut wire_cst_message_success_action_data,
15524 }
15525 #[repr(C)]
15526 #[derive(Clone, Copy)]
15527 pub struct wire_cst_SuccessAction_Url {
15528 data: *mut wire_cst_url_success_action_data,
15529 }
15530 #[repr(C)]
15531 #[derive(Clone, Copy)]
15532 pub struct wire_cst_success_action_processed {
15533 tag: i32,
15534 kind: SuccessActionProcessedKind,
15535 }
15536 #[repr(C)]
15537 #[derive(Clone, Copy)]
15538 pub union SuccessActionProcessedKind {
15539 Aes: wire_cst_SuccessActionProcessed_Aes,
15540 Message: wire_cst_SuccessActionProcessed_Message,
15541 Url: wire_cst_SuccessActionProcessed_Url,
15542 nil__: (),
15543 }
15544 #[repr(C)]
15545 #[derive(Clone, Copy)]
15546 pub struct wire_cst_SuccessActionProcessed_Aes {
15547 result: *mut wire_cst_aes_success_action_data_result,
15548 }
15549 #[repr(C)]
15550 #[derive(Clone, Copy)]
15551 pub struct wire_cst_SuccessActionProcessed_Message {
15552 data: *mut wire_cst_message_success_action_data,
15553 }
15554 #[repr(C)]
15555 #[derive(Clone, Copy)]
15556 pub struct wire_cst_SuccessActionProcessed_Url {
15557 data: *mut wire_cst_url_success_action_data,
15558 }
15559 #[repr(C)]
15560 #[derive(Clone, Copy)]
15561 pub struct wire_cst_symbol {
15562 grapheme: *mut wire_cst_list_prim_u_8_strict,
15563 template: *mut wire_cst_list_prim_u_8_strict,
15564 rtl: *mut bool,
15565 position: *mut u32,
15566 }
15567 #[repr(C)]
15568 #[derive(Clone, Copy)]
15569 pub struct wire_cst_url_success_action_data {
15570 description: *mut wire_cst_list_prim_u_8_strict,
15571 url: *mut wire_cst_list_prim_u_8_strict,
15572 matches_callback_domain: bool,
15573 }
15574 #[repr(C)]
15575 #[derive(Clone, Copy)]
15576 pub struct wire_cst_wallet_info {
15577 balance_sat: u64,
15578 pending_send_sat: u64,
15579 pending_receive_sat: u64,
15580 fingerprint: *mut wire_cst_list_prim_u_8_strict,
15581 pubkey: *mut wire_cst_list_prim_u_8_strict,
15582 asset_balances: *mut wire_cst_list_asset_balance,
15583 }
15584}
15585#[cfg(not(target_family = "wasm"))]
15586pub use io::*;