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