1#![allow(
5 non_camel_case_types,
6 unused,
7 non_snake_case,
8 clippy::needless_return,
9 clippy::redundant_closure_call,
10 clippy::redundant_closure,
11 clippy::useless_conversion,
12 clippy::unit_arg,
13 clippy::unused_unit,
14 clippy::double_parens,
15 clippy::let_and_return,
16 clippy::too_many_arguments,
17 clippy::match_single_binding,
18 clippy::clone_on_copy,
19 clippy::let_unit_value,
20 clippy::deref_addrof,
21 clippy::explicit_auto_deref,
22 clippy::borrow_deref_ref,
23 clippy::needless_borrow
24)]
25
26use crate::bindings::*;
29use crate::model::EventListener;
30use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
31use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
32use flutter_rust_bridge::{Handler, IntoIntoDart};
33
34flutter_rust_bridge::frb_generated_boilerplate!(
37 default_stream_sink_codec = DcoCodec,
38 default_rust_opaque = RustOpaqueNom,
39 default_rust_auto_opaque = RustAutoOpaqueNom,
40);
41pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.9.0";
42pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 464449310;
43
44flutter_rust_bridge::frb_generated_default_handler!();
47
48fn wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(
51 port_: flutter_rust_bridge::for_generated::MessagePort,
52 that: impl CstDecode<
53 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
54 >,
55 req: impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>,
56) {
57 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
58 flutter_rust_bridge::for_generated::TaskInfo {
59 debug_name: "BindingLiquidSdk_accept_payment_proposed_fees",
60 port: Some(port_),
61 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
62 },
63 move || {
64 let api_that = that.cst_decode();
65 let api_req = req.cst_decode();
66 move |context| async move {
67 transform_result_dco::<_, _, crate::error::PaymentError>(
68 (move || async move {
69 let mut api_that_guard = None;
70 let decode_indices_ =
71 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
72 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
73 &api_that, 0, false,
74 )],
75 );
76 for i in decode_indices_ {
77 match i {
78 0 => {
79 api_that_guard =
80 Some(api_that.lockable_decode_async_ref().await)
81 }
82 _ => unreachable!(),
83 }
84 }
85 let api_that_guard = api_that_guard.unwrap();
86 let output_ok =
87 crate::bindings::BindingLiquidSdk::accept_payment_proposed_fees(
88 &*api_that_guard,
89 api_req,
90 )
91 .await?;
92 Ok(output_ok)
93 })()
94 .await,
95 )
96 }
97 },
98 )
99}
100fn wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(
101 port_: flutter_rust_bridge::for_generated::MessagePort,
102 that: impl CstDecode<
103 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
104 >,
105 listener: impl CstDecode<
106 StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>,
107 >,
108) {
109 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
110 flutter_rust_bridge::for_generated::TaskInfo {
111 debug_name: "BindingLiquidSdk_add_event_listener",
112 port: Some(port_),
113 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
114 },
115 move || {
116 let api_that = that.cst_decode();
117 let api_listener = listener.cst_decode();
118 move |context| async move {
119 transform_result_dco::<_, _, crate::error::SdkError>(
120 (move || async move {
121 let mut api_that_guard = None;
122 let decode_indices_ =
123 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
124 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
125 &api_that, 0, false,
126 )],
127 );
128 for i in decode_indices_ {
129 match i {
130 0 => {
131 api_that_guard =
132 Some(api_that.lockable_decode_async_ref().await)
133 }
134 _ => unreachable!(),
135 }
136 }
137 let api_that_guard = api_that_guard.unwrap();
138 let output_ok = crate::bindings::BindingLiquidSdk::add_event_listener(
139 &*api_that_guard,
140 api_listener,
141 )
142 .await?;
143 Ok(output_ok)
144 })()
145 .await,
146 )
147 }
148 },
149 )
150}
151fn wire__crate__bindings__BindingLiquidSdk_backup_impl(
152 that: impl CstDecode<
153 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
154 >,
155 req: impl CstDecode<crate::model::BackupRequest>,
156) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
157 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
158 flutter_rust_bridge::for_generated::TaskInfo {
159 debug_name: "BindingLiquidSdk_backup",
160 port: None,
161 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
162 },
163 move || {
164 let api_that = that.cst_decode();
165 let api_req = req.cst_decode();
166 transform_result_dco::<_, _, crate::error::SdkError>((move || {
167 let mut api_that_guard = None;
168 let decode_indices_ =
169 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
170 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
171 &api_that, 0, false,
172 ),
173 ]);
174 for i in decode_indices_ {
175 match i {
176 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
177 _ => unreachable!(),
178 }
179 }
180 let api_that_guard = api_that_guard.unwrap();
181 let output_ok =
182 crate::bindings::BindingLiquidSdk::backup(&*api_that_guard, api_req)?;
183 Ok(output_ok)
184 })())
185 },
186 )
187}
188fn wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(
189 port_: flutter_rust_bridge::for_generated::MessagePort,
190 that: impl CstDecode<
191 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
192 >,
193 req: impl CstDecode<crate::model::BuyBitcoinRequest>,
194) {
195 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
196 flutter_rust_bridge::for_generated::TaskInfo {
197 debug_name: "BindingLiquidSdk_buy_bitcoin",
198 port: Some(port_),
199 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
200 },
201 move || {
202 let api_that = that.cst_decode();
203 let api_req = req.cst_decode();
204 move |context| async move {
205 transform_result_dco::<_, _, crate::error::PaymentError>(
206 (move || async move {
207 let mut api_that_guard = None;
208 let decode_indices_ =
209 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
210 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
211 &api_that, 0, false,
212 )],
213 );
214 for i in decode_indices_ {
215 match i {
216 0 => {
217 api_that_guard =
218 Some(api_that.lockable_decode_async_ref().await)
219 }
220 _ => unreachable!(),
221 }
222 }
223 let api_that_guard = api_that_guard.unwrap();
224 let output_ok = crate::bindings::BindingLiquidSdk::buy_bitcoin(
225 &*api_that_guard,
226 api_req,
227 )
228 .await?;
229 Ok(output_ok)
230 })()
231 .await,
232 )
233 }
234 },
235 )
236}
237fn wire__crate__bindings__BindingLiquidSdk_check_message_impl(
238 that: impl CstDecode<
239 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
240 >,
241 req: impl CstDecode<crate::model::CheckMessageRequest>,
242) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
243 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
244 flutter_rust_bridge::for_generated::TaskInfo {
245 debug_name: "BindingLiquidSdk_check_message",
246 port: None,
247 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
248 },
249 move || {
250 let api_that = that.cst_decode();
251 let api_req = req.cst_decode();
252 transform_result_dco::<_, _, crate::error::SdkError>((move || {
253 let mut api_that_guard = None;
254 let decode_indices_ =
255 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
256 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
257 &api_that, 0, false,
258 ),
259 ]);
260 for i in decode_indices_ {
261 match i {
262 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
263 _ => unreachable!(),
264 }
265 }
266 let api_that_guard = api_that_guard.unwrap();
267 let output_ok =
268 crate::bindings::BindingLiquidSdk::check_message(&*api_that_guard, api_req)?;
269 Ok(output_ok)
270 })())
271 },
272 )
273}
274fn wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(
275 port_: flutter_rust_bridge::for_generated::MessagePort,
276 that: impl CstDecode<
277 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
278 >,
279 req: impl CstDecode<crate::model::CreateBolt12InvoiceRequest>,
280) {
281 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
282 flutter_rust_bridge::for_generated::TaskInfo {
283 debug_name: "BindingLiquidSdk_create_bolt12_invoice",
284 port: Some(port_),
285 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
286 },
287 move || {
288 let api_that = that.cst_decode();
289 let api_req = req.cst_decode();
290 move |context| async move {
291 transform_result_dco::<_, _, crate::error::PaymentError>(
292 (move || async move {
293 let mut api_that_guard = None;
294 let decode_indices_ =
295 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
296 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
297 &api_that, 0, false,
298 )],
299 );
300 for i in decode_indices_ {
301 match i {
302 0 => {
303 api_that_guard =
304 Some(api_that.lockable_decode_async_ref().await)
305 }
306 _ => unreachable!(),
307 }
308 }
309 let api_that_guard = api_that_guard.unwrap();
310 let output_ok = crate::bindings::BindingLiquidSdk::create_bolt12_invoice(
311 &*api_that_guard,
312 api_req,
313 )
314 .await?;
315 Ok(output_ok)
316 })()
317 .await,
318 )
319 }
320 },
321 )
322}
323fn wire__crate__bindings__BindingLiquidSdk_disconnect_impl(
324 port_: flutter_rust_bridge::for_generated::MessagePort,
325 that: impl CstDecode<
326 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
327 >,
328) {
329 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
330 flutter_rust_bridge::for_generated::TaskInfo {
331 debug_name: "BindingLiquidSdk_disconnect",
332 port: Some(port_),
333 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
334 },
335 move || {
336 let api_that = that.cst_decode();
337 move |context| async move {
338 transform_result_dco::<_, _, crate::error::SdkError>(
339 (move || async move {
340 let mut api_that_guard = None;
341 let decode_indices_ =
342 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
343 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
344 &api_that, 0, false,
345 )],
346 );
347 for i in decode_indices_ {
348 match i {
349 0 => {
350 api_that_guard =
351 Some(api_that.lockable_decode_async_ref().await)
352 }
353 _ => unreachable!(),
354 }
355 }
356 let api_that_guard = api_that_guard.unwrap();
357 let output_ok =
358 crate::bindings::BindingLiquidSdk::disconnect(&*api_that_guard).await?;
359 Ok(output_ok)
360 })()
361 .await,
362 )
363 }
364 },
365 )
366}
367fn wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(
368 that: impl CstDecode<
369 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
370 >,
371) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
372 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
373 flutter_rust_bridge::for_generated::TaskInfo {
374 debug_name: "BindingLiquidSdk_empty_wallet_cache",
375 port: None,
376 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
377 },
378 move || {
379 let api_that = that.cst_decode();
380 transform_result_dco::<_, _, crate::error::SdkError>((move || {
381 let mut api_that_guard = None;
382 let decode_indices_ =
383 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
384 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
385 &api_that, 0, false,
386 ),
387 ]);
388 for i in decode_indices_ {
389 match i {
390 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
391 _ => unreachable!(),
392 }
393 }
394 let api_that_guard = api_that_guard.unwrap();
395 let output_ok =
396 crate::bindings::BindingLiquidSdk::empty_wallet_cache(&*api_that_guard)?;
397 Ok(output_ok)
398 })())
399 },
400 )
401}
402fn wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(
403 port_: flutter_rust_bridge::for_generated::MessagePort,
404 that: impl CstDecode<
405 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
406 >,
407) {
408 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
409 flutter_rust_bridge::for_generated::TaskInfo {
410 debug_name: "BindingLiquidSdk_fetch_fiat_rates",
411 port: Some(port_),
412 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
413 },
414 move || {
415 let api_that = that.cst_decode();
416 move |context| async move {
417 transform_result_dco::<_, _, crate::error::SdkError>(
418 (move || async move {
419 let mut api_that_guard = None;
420 let decode_indices_ =
421 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
422 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
423 &api_that, 0, false,
424 )],
425 );
426 for i in decode_indices_ {
427 match i {
428 0 => {
429 api_that_guard =
430 Some(api_that.lockable_decode_async_ref().await)
431 }
432 _ => unreachable!(),
433 }
434 }
435 let api_that_guard = api_that_guard.unwrap();
436 let output_ok =
437 crate::bindings::BindingLiquidSdk::fetch_fiat_rates(&*api_that_guard)
438 .await?;
439 Ok(output_ok)
440 })()
441 .await,
442 )
443 }
444 },
445 )
446}
447fn wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(
448 port_: flutter_rust_bridge::for_generated::MessagePort,
449 that: impl CstDecode<
450 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
451 >,
452) {
453 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
454 flutter_rust_bridge::for_generated::TaskInfo {
455 debug_name: "BindingLiquidSdk_fetch_lightning_limits",
456 port: Some(port_),
457 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
458 },
459 move || {
460 let api_that = that.cst_decode();
461 move |context| async move {
462 transform_result_dco::<_, _, crate::error::PaymentError>(
463 (move || async move {
464 let mut api_that_guard = None;
465 let decode_indices_ =
466 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
467 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
468 &api_that, 0, false,
469 )],
470 );
471 for i in decode_indices_ {
472 match i {
473 0 => {
474 api_that_guard =
475 Some(api_that.lockable_decode_async_ref().await)
476 }
477 _ => unreachable!(),
478 }
479 }
480 let api_that_guard = api_that_guard.unwrap();
481 let output_ok = crate::bindings::BindingLiquidSdk::fetch_lightning_limits(
482 &*api_that_guard,
483 )
484 .await?;
485 Ok(output_ok)
486 })()
487 .await,
488 )
489 }
490 },
491 )
492}
493fn wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(
494 port_: flutter_rust_bridge::for_generated::MessagePort,
495 that: impl CstDecode<
496 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
497 >,
498) {
499 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
500 flutter_rust_bridge::for_generated::TaskInfo {
501 debug_name: "BindingLiquidSdk_fetch_onchain_limits",
502 port: Some(port_),
503 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
504 },
505 move || {
506 let api_that = that.cst_decode();
507 move |context| async move {
508 transform_result_dco::<_, _, crate::error::PaymentError>(
509 (move || async move {
510 let mut api_that_guard = None;
511 let decode_indices_ =
512 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
513 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
514 &api_that, 0, false,
515 )],
516 );
517 for i in decode_indices_ {
518 match i {
519 0 => {
520 api_that_guard =
521 Some(api_that.lockable_decode_async_ref().await)
522 }
523 _ => unreachable!(),
524 }
525 }
526 let api_that_guard = api_that_guard.unwrap();
527 let output_ok = crate::bindings::BindingLiquidSdk::fetch_onchain_limits(
528 &*api_that_guard,
529 )
530 .await?;
531 Ok(output_ok)
532 })()
533 .await,
534 )
535 }
536 },
537 )
538}
539fn wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(
540 port_: flutter_rust_bridge::for_generated::MessagePort,
541 that: impl CstDecode<
542 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
543 >,
544 req: impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>,
545) {
546 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
547 flutter_rust_bridge::for_generated::TaskInfo {
548 debug_name: "BindingLiquidSdk_fetch_payment_proposed_fees",
549 port: Some(port_),
550 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
551 },
552 move || {
553 let api_that = that.cst_decode();
554 let api_req = req.cst_decode();
555 move |context| async move {
556 transform_result_dco::<_, _, crate::error::SdkError>(
557 (move || async move {
558 let mut api_that_guard = None;
559 let decode_indices_ =
560 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
561 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
562 &api_that, 0, false,
563 )],
564 );
565 for i in decode_indices_ {
566 match i {
567 0 => {
568 api_that_guard =
569 Some(api_that.lockable_decode_async_ref().await)
570 }
571 _ => unreachable!(),
572 }
573 }
574 let api_that_guard = api_that_guard.unwrap();
575 let output_ok =
576 crate::bindings::BindingLiquidSdk::fetch_payment_proposed_fees(
577 &*api_that_guard,
578 api_req,
579 )
580 .await?;
581 Ok(output_ok)
582 })()
583 .await,
584 )
585 }
586 },
587 )
588}
589fn wire__crate__bindings__BindingLiquidSdk_get_info_impl(
590 port_: flutter_rust_bridge::for_generated::MessagePort,
591 that: impl CstDecode<
592 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
593 >,
594) {
595 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
596 flutter_rust_bridge::for_generated::TaskInfo {
597 debug_name: "BindingLiquidSdk_get_info",
598 port: Some(port_),
599 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
600 },
601 move || {
602 let api_that = that.cst_decode();
603 move |context| async move {
604 transform_result_dco::<_, _, crate::error::SdkError>(
605 (move || async move {
606 let mut api_that_guard = None;
607 let decode_indices_ =
608 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
609 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
610 &api_that, 0, false,
611 )],
612 );
613 for i in decode_indices_ {
614 match i {
615 0 => {
616 api_that_guard =
617 Some(api_that.lockable_decode_async_ref().await)
618 }
619 _ => unreachable!(),
620 }
621 }
622 let api_that_guard = api_that_guard.unwrap();
623 let output_ok =
624 crate::bindings::BindingLiquidSdk::get_info(&*api_that_guard).await?;
625 Ok(output_ok)
626 })()
627 .await,
628 )
629 }
630 },
631 )
632}
633fn wire__crate__bindings__BindingLiquidSdk_get_payment_impl(
634 port_: flutter_rust_bridge::for_generated::MessagePort,
635 that: impl CstDecode<
636 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
637 >,
638 req: impl CstDecode<crate::model::GetPaymentRequest>,
639) {
640 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
641 flutter_rust_bridge::for_generated::TaskInfo {
642 debug_name: "BindingLiquidSdk_get_payment",
643 port: Some(port_),
644 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
645 },
646 move || {
647 let api_that = that.cst_decode();
648 let api_req = req.cst_decode();
649 move |context| async move {
650 transform_result_dco::<_, _, crate::error::PaymentError>(
651 (move || async move {
652 let mut api_that_guard = None;
653 let decode_indices_ =
654 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
655 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
656 &api_that, 0, false,
657 )],
658 );
659 for i in decode_indices_ {
660 match i {
661 0 => {
662 api_that_guard =
663 Some(api_that.lockable_decode_async_ref().await)
664 }
665 _ => unreachable!(),
666 }
667 }
668 let api_that_guard = api_that_guard.unwrap();
669 let output_ok = crate::bindings::BindingLiquidSdk::get_payment(
670 &*api_that_guard,
671 api_req,
672 )
673 .await?;
674 Ok(output_ok)
675 })()
676 .await,
677 )
678 }
679 },
680 )
681}
682fn wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(
683 port_: flutter_rust_bridge::for_generated::MessagePort,
684 that: impl CstDecode<
685 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
686 >,
687) {
688 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
689 flutter_rust_bridge::for_generated::TaskInfo {
690 debug_name: "BindingLiquidSdk_list_fiat_currencies",
691 port: Some(port_),
692 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
693 },
694 move || {
695 let api_that = that.cst_decode();
696 move |context| async move {
697 transform_result_dco::<_, _, crate::error::SdkError>(
698 (move || async move {
699 let mut api_that_guard = None;
700 let decode_indices_ =
701 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
702 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
703 &api_that, 0, false,
704 )],
705 );
706 for i in decode_indices_ {
707 match i {
708 0 => {
709 api_that_guard =
710 Some(api_that.lockable_decode_async_ref().await)
711 }
712 _ => unreachable!(),
713 }
714 }
715 let api_that_guard = api_that_guard.unwrap();
716 let output_ok = crate::bindings::BindingLiquidSdk::list_fiat_currencies(
717 &*api_that_guard,
718 )
719 .await?;
720 Ok(output_ok)
721 })()
722 .await,
723 )
724 }
725 },
726 )
727}
728fn wire__crate__bindings__BindingLiquidSdk_list_payments_impl(
729 port_: flutter_rust_bridge::for_generated::MessagePort,
730 that: impl CstDecode<
731 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
732 >,
733 req: impl CstDecode<crate::model::ListPaymentsRequest>,
734) {
735 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
736 flutter_rust_bridge::for_generated::TaskInfo {
737 debug_name: "BindingLiquidSdk_list_payments",
738 port: Some(port_),
739 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
740 },
741 move || {
742 let api_that = that.cst_decode();
743 let api_req = req.cst_decode();
744 move |context| async move {
745 transform_result_dco::<_, _, crate::error::PaymentError>(
746 (move || async move {
747 let mut api_that_guard = None;
748 let decode_indices_ =
749 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
750 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
751 &api_that, 0, false,
752 )],
753 );
754 for i in decode_indices_ {
755 match i {
756 0 => {
757 api_that_guard =
758 Some(api_that.lockable_decode_async_ref().await)
759 }
760 _ => unreachable!(),
761 }
762 }
763 let api_that_guard = api_that_guard.unwrap();
764 let output_ok = crate::bindings::BindingLiquidSdk::list_payments(
765 &*api_that_guard,
766 api_req,
767 )
768 .await?;
769 Ok(output_ok)
770 })()
771 .await,
772 )
773 }
774 },
775 )
776}
777fn wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(
778 port_: flutter_rust_bridge::for_generated::MessagePort,
779 that: impl CstDecode<
780 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
781 >,
782) {
783 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
784 flutter_rust_bridge::for_generated::TaskInfo {
785 debug_name: "BindingLiquidSdk_list_refundables",
786 port: Some(port_),
787 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
788 },
789 move || {
790 let api_that = that.cst_decode();
791 move |context| async move {
792 transform_result_dco::<_, _, crate::error::SdkError>(
793 (move || async move {
794 let mut api_that_guard = None;
795 let decode_indices_ =
796 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
797 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
798 &api_that, 0, false,
799 )],
800 );
801 for i in decode_indices_ {
802 match i {
803 0 => {
804 api_that_guard =
805 Some(api_that.lockable_decode_async_ref().await)
806 }
807 _ => unreachable!(),
808 }
809 }
810 let api_that_guard = api_that_guard.unwrap();
811 let output_ok =
812 crate::bindings::BindingLiquidSdk::list_refundables(&*api_that_guard)
813 .await?;
814 Ok(output_ok)
815 })()
816 .await,
817 )
818 }
819 },
820 )
821}
822fn wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(
823 port_: flutter_rust_bridge::for_generated::MessagePort,
824 that: impl CstDecode<
825 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
826 >,
827 req_data: impl CstDecode<crate::bindings::LnUrlAuthRequestData>,
828) {
829 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
830 flutter_rust_bridge::for_generated::TaskInfo {
831 debug_name: "BindingLiquidSdk_lnurl_auth",
832 port: Some(port_),
833 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
834 },
835 move || {
836 let api_that = that.cst_decode();
837 let api_req_data = req_data.cst_decode();
838 move |context| async move {
839 transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlAuthError>(
840 (move || async move {
841 let mut api_that_guard = None;
842 let decode_indices_ =
843 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
844 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
845 &api_that, 0, false,
846 )],
847 );
848 for i in decode_indices_ {
849 match i {
850 0 => {
851 api_that_guard =
852 Some(api_that.lockable_decode_async_ref().await)
853 }
854 _ => unreachable!(),
855 }
856 }
857 let api_that_guard = api_that_guard.unwrap();
858 let output_ok = crate::bindings::BindingLiquidSdk::lnurl_auth(
859 &*api_that_guard,
860 api_req_data,
861 )
862 .await?;
863 Ok(output_ok)
864 })()
865 .await,
866 )
867 }
868 },
869 )
870}
871fn wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(
872 port_: flutter_rust_bridge::for_generated::MessagePort,
873 that: impl CstDecode<
874 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
875 >,
876 req: impl CstDecode<crate::model::LnUrlPayRequest>,
877) {
878 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
879 flutter_rust_bridge::for_generated::TaskInfo {
880 debug_name: "BindingLiquidSdk_lnurl_pay",
881 port: Some(port_),
882 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
883 },
884 move || {
885 let api_that = that.cst_decode();
886 let api_req = req.cst_decode();
887 move |context| async move {
888 transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlPayError>(
889 (move || async move {
890 let mut api_that_guard = None;
891 let decode_indices_ =
892 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
893 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
894 &api_that, 0, false,
895 )],
896 );
897 for i in decode_indices_ {
898 match i {
899 0 => {
900 api_that_guard =
901 Some(api_that.lockable_decode_async_ref().await)
902 }
903 _ => unreachable!(),
904 }
905 }
906 let api_that_guard = api_that_guard.unwrap();
907 let output_ok =
908 crate::bindings::BindingLiquidSdk::lnurl_pay(&*api_that_guard, api_req)
909 .await?;
910 Ok(output_ok)
911 })()
912 .await,
913 )
914 }
915 },
916 )
917}
918fn wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(
919 port_: flutter_rust_bridge::for_generated::MessagePort,
920 that: impl CstDecode<
921 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
922 >,
923 req: impl CstDecode<crate::bindings::LnUrlWithdrawRequest>,
924) {
925 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
926 flutter_rust_bridge::for_generated::TaskInfo {
927 debug_name: "BindingLiquidSdk_lnurl_withdraw",
928 port: Some(port_),
929 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
930 },
931 move || {
932 let api_that = that.cst_decode();
933 let api_req = req.cst_decode();
934 move |context| async move {
935 transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlWithdrawError>(
936 (move || async move {
937 let mut api_that_guard = None;
938 let decode_indices_ =
939 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
940 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
941 &api_that, 0, false,
942 )],
943 );
944 for i in decode_indices_ {
945 match i {
946 0 => {
947 api_that_guard =
948 Some(api_that.lockable_decode_async_ref().await)
949 }
950 _ => unreachable!(),
951 }
952 }
953 let api_that_guard = api_that_guard.unwrap();
954 let output_ok = crate::bindings::BindingLiquidSdk::lnurl_withdraw(
955 &*api_that_guard,
956 api_req,
957 )
958 .await?;
959 Ok(output_ok)
960 })()
961 .await,
962 )
963 }
964 },
965 )
966}
967fn wire__crate__bindings__BindingLiquidSdk_parse_impl(
968 port_: flutter_rust_bridge::for_generated::MessagePort,
969 that: impl CstDecode<
970 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
971 >,
972 input: impl CstDecode<String>,
973) {
974 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
975 flutter_rust_bridge::for_generated::TaskInfo {
976 debug_name: "BindingLiquidSdk_parse",
977 port: Some(port_),
978 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
979 },
980 move || {
981 let api_that = that.cst_decode();
982 let api_input = input.cst_decode();
983 move |context| async move {
984 transform_result_dco::<_, _, crate::error::PaymentError>(
985 (move || async move {
986 let mut api_that_guard = None;
987 let decode_indices_ =
988 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
989 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
990 &api_that, 0, false,
991 )],
992 );
993 for i in decode_indices_ {
994 match i {
995 0 => {
996 api_that_guard =
997 Some(api_that.lockable_decode_async_ref().await)
998 }
999 _ => unreachable!(),
1000 }
1001 }
1002 let api_that_guard = api_that_guard.unwrap();
1003 let output_ok =
1004 crate::bindings::BindingLiquidSdk::parse(&*api_that_guard, api_input)
1005 .await?;
1006 Ok(output_ok)
1007 })()
1008 .await,
1009 )
1010 }
1011 },
1012 )
1013}
1014fn wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(
1015 port_: flutter_rust_bridge::for_generated::MessagePort,
1016 that: impl CstDecode<
1017 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1018 >,
1019 req: impl CstDecode<crate::model::PayOnchainRequest>,
1020) {
1021 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1022 flutter_rust_bridge::for_generated::TaskInfo {
1023 debug_name: "BindingLiquidSdk_pay_onchain",
1024 port: Some(port_),
1025 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1026 },
1027 move || {
1028 let api_that = that.cst_decode();
1029 let api_req = req.cst_decode();
1030 move |context| async move {
1031 transform_result_dco::<_, _, crate::error::PaymentError>(
1032 (move || async move {
1033 let mut api_that_guard = None;
1034 let decode_indices_ =
1035 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1036 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1037 &api_that, 0, false,
1038 )],
1039 );
1040 for i in decode_indices_ {
1041 match i {
1042 0 => {
1043 api_that_guard =
1044 Some(api_that.lockable_decode_async_ref().await)
1045 }
1046 _ => unreachable!(),
1047 }
1048 }
1049 let api_that_guard = api_that_guard.unwrap();
1050 let output_ok = crate::bindings::BindingLiquidSdk::pay_onchain(
1051 &*api_that_guard,
1052 api_req,
1053 )
1054 .await?;
1055 Ok(output_ok)
1056 })()
1057 .await,
1058 )
1059 }
1060 },
1061 )
1062}
1063fn wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(
1064 port_: flutter_rust_bridge::for_generated::MessagePort,
1065 that: impl CstDecode<
1066 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1067 >,
1068 req: impl CstDecode<crate::model::PrepareBuyBitcoinRequest>,
1069) {
1070 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1071 flutter_rust_bridge::for_generated::TaskInfo {
1072 debug_name: "BindingLiquidSdk_prepare_buy_bitcoin",
1073 port: Some(port_),
1074 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1075 },
1076 move || {
1077 let api_that = that.cst_decode();
1078 let api_req = req.cst_decode();
1079 move |context| async move {
1080 transform_result_dco::<_, _, crate::error::PaymentError>(
1081 (move || async move {
1082 let mut api_that_guard = None;
1083 let decode_indices_ =
1084 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1085 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1086 &api_that, 0, false,
1087 )],
1088 );
1089 for i in decode_indices_ {
1090 match i {
1091 0 => {
1092 api_that_guard =
1093 Some(api_that.lockable_decode_async_ref().await)
1094 }
1095 _ => unreachable!(),
1096 }
1097 }
1098 let api_that_guard = api_that_guard.unwrap();
1099 let output_ok = crate::bindings::BindingLiquidSdk::prepare_buy_bitcoin(
1100 &*api_that_guard,
1101 api_req,
1102 )
1103 .await?;
1104 Ok(output_ok)
1105 })()
1106 .await,
1107 )
1108 }
1109 },
1110 )
1111}
1112fn wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(
1113 port_: flutter_rust_bridge::for_generated::MessagePort,
1114 that: impl CstDecode<
1115 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1116 >,
1117 req: impl CstDecode<crate::model::PrepareLnUrlPayRequest>,
1118) {
1119 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1120 flutter_rust_bridge::for_generated::TaskInfo {
1121 debug_name: "BindingLiquidSdk_prepare_lnurl_pay",
1122 port: Some(port_),
1123 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1124 },
1125 move || {
1126 let api_that = that.cst_decode();
1127 let api_req = req.cst_decode();
1128 move |context| async move {
1129 transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlPayError>(
1130 (move || async move {
1131 let mut api_that_guard = None;
1132 let decode_indices_ =
1133 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1134 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1135 &api_that, 0, false,
1136 )],
1137 );
1138 for i in decode_indices_ {
1139 match i {
1140 0 => {
1141 api_that_guard =
1142 Some(api_that.lockable_decode_async_ref().await)
1143 }
1144 _ => unreachable!(),
1145 }
1146 }
1147 let api_that_guard = api_that_guard.unwrap();
1148 let output_ok = crate::bindings::BindingLiquidSdk::prepare_lnurl_pay(
1149 &*api_that_guard,
1150 api_req,
1151 )
1152 .await?;
1153 Ok(output_ok)
1154 })()
1155 .await,
1156 )
1157 }
1158 },
1159 )
1160}
1161fn wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(
1162 port_: flutter_rust_bridge::for_generated::MessagePort,
1163 that: impl CstDecode<
1164 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1165 >,
1166 req: impl CstDecode<crate::model::PreparePayOnchainRequest>,
1167) {
1168 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1169 flutter_rust_bridge::for_generated::TaskInfo {
1170 debug_name: "BindingLiquidSdk_prepare_pay_onchain",
1171 port: Some(port_),
1172 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1173 },
1174 move || {
1175 let api_that = that.cst_decode();
1176 let api_req = req.cst_decode();
1177 move |context| async move {
1178 transform_result_dco::<_, _, crate::error::PaymentError>(
1179 (move || async move {
1180 let mut api_that_guard = None;
1181 let decode_indices_ =
1182 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1183 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1184 &api_that, 0, false,
1185 )],
1186 );
1187 for i in decode_indices_ {
1188 match i {
1189 0 => {
1190 api_that_guard =
1191 Some(api_that.lockable_decode_async_ref().await)
1192 }
1193 _ => unreachable!(),
1194 }
1195 }
1196 let api_that_guard = api_that_guard.unwrap();
1197 let output_ok = crate::bindings::BindingLiquidSdk::prepare_pay_onchain(
1198 &*api_that_guard,
1199 api_req,
1200 )
1201 .await?;
1202 Ok(output_ok)
1203 })()
1204 .await,
1205 )
1206 }
1207 },
1208 )
1209}
1210fn wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(
1211 port_: flutter_rust_bridge::for_generated::MessagePort,
1212 that: impl CstDecode<
1213 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1214 >,
1215 req: impl CstDecode<crate::model::PrepareReceiveRequest>,
1216) {
1217 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1218 flutter_rust_bridge::for_generated::TaskInfo {
1219 debug_name: "BindingLiquidSdk_prepare_receive_payment",
1220 port: Some(port_),
1221 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1222 },
1223 move || {
1224 let api_that = that.cst_decode();
1225 let api_req = req.cst_decode();
1226 move |context| async move {
1227 transform_result_dco::<_, _, crate::error::PaymentError>(
1228 (move || async move {
1229 let mut api_that_guard = None;
1230 let decode_indices_ =
1231 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1232 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1233 &api_that, 0, false,
1234 )],
1235 );
1236 for i in decode_indices_ {
1237 match i {
1238 0 => {
1239 api_that_guard =
1240 Some(api_that.lockable_decode_async_ref().await)
1241 }
1242 _ => unreachable!(),
1243 }
1244 }
1245 let api_that_guard = api_that_guard.unwrap();
1246 let output_ok = crate::bindings::BindingLiquidSdk::prepare_receive_payment(
1247 &*api_that_guard,
1248 api_req,
1249 )
1250 .await?;
1251 Ok(output_ok)
1252 })()
1253 .await,
1254 )
1255 }
1256 },
1257 )
1258}
1259fn wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(
1260 port_: flutter_rust_bridge::for_generated::MessagePort,
1261 that: impl CstDecode<
1262 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1263 >,
1264 req: impl CstDecode<crate::model::PrepareRefundRequest>,
1265) {
1266 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1267 flutter_rust_bridge::for_generated::TaskInfo {
1268 debug_name: "BindingLiquidSdk_prepare_refund",
1269 port: Some(port_),
1270 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1271 },
1272 move || {
1273 let api_that = that.cst_decode();
1274 let api_req = req.cst_decode();
1275 move |context| async move {
1276 transform_result_dco::<_, _, crate::error::SdkError>(
1277 (move || async move {
1278 let mut api_that_guard = None;
1279 let decode_indices_ =
1280 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1281 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1282 &api_that, 0, false,
1283 )],
1284 );
1285 for i in decode_indices_ {
1286 match i {
1287 0 => {
1288 api_that_guard =
1289 Some(api_that.lockable_decode_async_ref().await)
1290 }
1291 _ => unreachable!(),
1292 }
1293 }
1294 let api_that_guard = api_that_guard.unwrap();
1295 let output_ok = crate::bindings::BindingLiquidSdk::prepare_refund(
1296 &*api_that_guard,
1297 api_req,
1298 )
1299 .await?;
1300 Ok(output_ok)
1301 })()
1302 .await,
1303 )
1304 }
1305 },
1306 )
1307}
1308fn wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(
1309 port_: flutter_rust_bridge::for_generated::MessagePort,
1310 that: impl CstDecode<
1311 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1312 >,
1313 req: impl CstDecode<crate::model::PrepareSendRequest>,
1314) {
1315 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1316 flutter_rust_bridge::for_generated::TaskInfo {
1317 debug_name: "BindingLiquidSdk_prepare_send_payment",
1318 port: Some(port_),
1319 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1320 },
1321 move || {
1322 let api_that = that.cst_decode();
1323 let api_req = req.cst_decode();
1324 move |context| async move {
1325 transform_result_dco::<_, _, crate::error::PaymentError>(
1326 (move || async move {
1327 let mut api_that_guard = None;
1328 let decode_indices_ =
1329 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1330 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1331 &api_that, 0, false,
1332 )],
1333 );
1334 for i in decode_indices_ {
1335 match i {
1336 0 => {
1337 api_that_guard =
1338 Some(api_that.lockable_decode_async_ref().await)
1339 }
1340 _ => unreachable!(),
1341 }
1342 }
1343 let api_that_guard = api_that_guard.unwrap();
1344 let output_ok = crate::bindings::BindingLiquidSdk::prepare_send_payment(
1345 &*api_that_guard,
1346 api_req,
1347 )
1348 .await?;
1349 Ok(output_ok)
1350 })()
1351 .await,
1352 )
1353 }
1354 },
1355 )
1356}
1357fn wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(
1358 port_: flutter_rust_bridge::for_generated::MessagePort,
1359 that: impl CstDecode<
1360 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1361 >,
1362 req: impl CstDecode<crate::model::ReceivePaymentRequest>,
1363) {
1364 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1365 flutter_rust_bridge::for_generated::TaskInfo {
1366 debug_name: "BindingLiquidSdk_receive_payment",
1367 port: Some(port_),
1368 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1369 },
1370 move || {
1371 let api_that = that.cst_decode();
1372 let api_req = req.cst_decode();
1373 move |context| async move {
1374 transform_result_dco::<_, _, crate::error::PaymentError>(
1375 (move || async move {
1376 let mut api_that_guard = None;
1377 let decode_indices_ =
1378 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1379 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1380 &api_that, 0, false,
1381 )],
1382 );
1383 for i in decode_indices_ {
1384 match i {
1385 0 => {
1386 api_that_guard =
1387 Some(api_that.lockable_decode_async_ref().await)
1388 }
1389 _ => unreachable!(),
1390 }
1391 }
1392 let api_that_guard = api_that_guard.unwrap();
1393 let output_ok = crate::bindings::BindingLiquidSdk::receive_payment(
1394 &*api_that_guard,
1395 api_req,
1396 )
1397 .await?;
1398 Ok(output_ok)
1399 })()
1400 .await,
1401 )
1402 }
1403 },
1404 )
1405}
1406fn wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(
1407 port_: flutter_rust_bridge::for_generated::MessagePort,
1408 that: impl CstDecode<
1409 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1410 >,
1411) {
1412 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1413 flutter_rust_bridge::for_generated::TaskInfo {
1414 debug_name: "BindingLiquidSdk_recommended_fees",
1415 port: Some(port_),
1416 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1417 },
1418 move || {
1419 let api_that = that.cst_decode();
1420 move |context| async move {
1421 transform_result_dco::<_, _, crate::error::SdkError>(
1422 (move || async move {
1423 let mut api_that_guard = None;
1424 let decode_indices_ =
1425 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1426 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1427 &api_that, 0, false,
1428 )],
1429 );
1430 for i in decode_indices_ {
1431 match i {
1432 0 => {
1433 api_that_guard =
1434 Some(api_that.lockable_decode_async_ref().await)
1435 }
1436 _ => unreachable!(),
1437 }
1438 }
1439 let api_that_guard = api_that_guard.unwrap();
1440 let output_ok =
1441 crate::bindings::BindingLiquidSdk::recommended_fees(&*api_that_guard)
1442 .await?;
1443 Ok(output_ok)
1444 })()
1445 .await,
1446 )
1447 }
1448 },
1449 )
1450}
1451fn wire__crate__bindings__BindingLiquidSdk_refund_impl(
1452 port_: flutter_rust_bridge::for_generated::MessagePort,
1453 that: impl CstDecode<
1454 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1455 >,
1456 req: impl CstDecode<crate::model::RefundRequest>,
1457) {
1458 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1459 flutter_rust_bridge::for_generated::TaskInfo {
1460 debug_name: "BindingLiquidSdk_refund",
1461 port: Some(port_),
1462 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1463 },
1464 move || {
1465 let api_that = that.cst_decode();
1466 let api_req = req.cst_decode();
1467 move |context| async move {
1468 transform_result_dco::<_, _, crate::error::PaymentError>(
1469 (move || async move {
1470 let mut api_that_guard = None;
1471 let decode_indices_ =
1472 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1473 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1474 &api_that, 0, false,
1475 )],
1476 );
1477 for i in decode_indices_ {
1478 match i {
1479 0 => {
1480 api_that_guard =
1481 Some(api_that.lockable_decode_async_ref().await)
1482 }
1483 _ => unreachable!(),
1484 }
1485 }
1486 let api_that_guard = api_that_guard.unwrap();
1487 let output_ok =
1488 crate::bindings::BindingLiquidSdk::refund(&*api_that_guard, api_req)
1489 .await?;
1490 Ok(output_ok)
1491 })()
1492 .await,
1493 )
1494 }
1495 },
1496 )
1497}
1498fn wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(
1499 port_: flutter_rust_bridge::for_generated::MessagePort,
1500 that: impl CstDecode<
1501 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1502 >,
1503 webhook_url: impl CstDecode<String>,
1504) {
1505 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1506 flutter_rust_bridge::for_generated::TaskInfo {
1507 debug_name: "BindingLiquidSdk_register_webhook",
1508 port: Some(port_),
1509 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1510 },
1511 move || {
1512 let api_that = that.cst_decode();
1513 let api_webhook_url = webhook_url.cst_decode();
1514 move |context| async move {
1515 transform_result_dco::<_, _, crate::error::SdkError>(
1516 (move || async move {
1517 let mut api_that_guard = None;
1518 let decode_indices_ =
1519 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1520 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1521 &api_that, 0, false,
1522 )],
1523 );
1524 for i in decode_indices_ {
1525 match i {
1526 0 => {
1527 api_that_guard =
1528 Some(api_that.lockable_decode_async_ref().await)
1529 }
1530 _ => unreachable!(),
1531 }
1532 }
1533 let api_that_guard = api_that_guard.unwrap();
1534 let output_ok = crate::bindings::BindingLiquidSdk::register_webhook(
1535 &*api_that_guard,
1536 api_webhook_url,
1537 )
1538 .await?;
1539 Ok(output_ok)
1540 })()
1541 .await,
1542 )
1543 }
1544 },
1545 )
1546}
1547fn wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(
1548 port_: flutter_rust_bridge::for_generated::MessagePort,
1549 that: impl CstDecode<
1550 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1551 >,
1552) {
1553 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1554 flutter_rust_bridge::for_generated::TaskInfo {
1555 debug_name: "BindingLiquidSdk_rescan_onchain_swaps",
1556 port: Some(port_),
1557 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1558 },
1559 move || {
1560 let api_that = that.cst_decode();
1561 move |context| async move {
1562 transform_result_dco::<_, _, crate::error::SdkError>(
1563 (move || async move {
1564 let mut api_that_guard = None;
1565 let decode_indices_ =
1566 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1567 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1568 &api_that, 0, false,
1569 )],
1570 );
1571 for i in decode_indices_ {
1572 match i {
1573 0 => {
1574 api_that_guard =
1575 Some(api_that.lockable_decode_async_ref().await)
1576 }
1577 _ => unreachable!(),
1578 }
1579 }
1580 let api_that_guard = api_that_guard.unwrap();
1581 let output_ok = crate::bindings::BindingLiquidSdk::rescan_onchain_swaps(
1582 &*api_that_guard,
1583 )
1584 .await?;
1585 Ok(output_ok)
1586 })()
1587 .await,
1588 )
1589 }
1590 },
1591 )
1592}
1593fn wire__crate__bindings__BindingLiquidSdk_restore_impl(
1594 that: impl CstDecode<
1595 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1596 >,
1597 req: impl CstDecode<crate::model::RestoreRequest>,
1598) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1599 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1600 flutter_rust_bridge::for_generated::TaskInfo {
1601 debug_name: "BindingLiquidSdk_restore",
1602 port: None,
1603 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1604 },
1605 move || {
1606 let api_that = that.cst_decode();
1607 let api_req = req.cst_decode();
1608 transform_result_dco::<_, _, crate::error::SdkError>((move || {
1609 let mut api_that_guard = None;
1610 let decode_indices_ =
1611 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
1612 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1613 &api_that, 0, false,
1614 ),
1615 ]);
1616 for i in decode_indices_ {
1617 match i {
1618 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
1619 _ => unreachable!(),
1620 }
1621 }
1622 let api_that_guard = api_that_guard.unwrap();
1623 let output_ok =
1624 crate::bindings::BindingLiquidSdk::restore(&*api_that_guard, api_req)?;
1625 Ok(output_ok)
1626 })())
1627 },
1628 )
1629}
1630fn wire__crate__bindings__BindingLiquidSdk_send_payment_impl(
1631 port_: flutter_rust_bridge::for_generated::MessagePort,
1632 that: impl CstDecode<
1633 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1634 >,
1635 req: impl CstDecode<crate::model::SendPaymentRequest>,
1636) {
1637 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1638 flutter_rust_bridge::for_generated::TaskInfo {
1639 debug_name: "BindingLiquidSdk_send_payment",
1640 port: Some(port_),
1641 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1642 },
1643 move || {
1644 let api_that = that.cst_decode();
1645 let api_req = req.cst_decode();
1646 move |context| async move {
1647 transform_result_dco::<_, _, crate::error::PaymentError>(
1648 (move || async move {
1649 let mut api_that_guard = None;
1650 let decode_indices_ =
1651 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1652 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1653 &api_that, 0, false,
1654 )],
1655 );
1656 for i in decode_indices_ {
1657 match i {
1658 0 => {
1659 api_that_guard =
1660 Some(api_that.lockable_decode_async_ref().await)
1661 }
1662 _ => unreachable!(),
1663 }
1664 }
1665 let api_that_guard = api_that_guard.unwrap();
1666 let output_ok = crate::bindings::BindingLiquidSdk::send_payment(
1667 &*api_that_guard,
1668 api_req,
1669 )
1670 .await?;
1671 Ok(output_ok)
1672 })()
1673 .await,
1674 )
1675 }
1676 },
1677 )
1678}
1679fn wire__crate__bindings__BindingLiquidSdk_sign_message_impl(
1680 that: impl CstDecode<
1681 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1682 >,
1683 req: impl CstDecode<crate::model::SignMessageRequest>,
1684) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1685 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1686 flutter_rust_bridge::for_generated::TaskInfo {
1687 debug_name: "BindingLiquidSdk_sign_message",
1688 port: None,
1689 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1690 },
1691 move || {
1692 let api_that = that.cst_decode();
1693 let api_req = req.cst_decode();
1694 transform_result_dco::<_, _, crate::error::SdkError>((move || {
1695 let mut api_that_guard = None;
1696 let decode_indices_ =
1697 flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
1698 flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1699 &api_that, 0, false,
1700 ),
1701 ]);
1702 for i in decode_indices_ {
1703 match i {
1704 0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
1705 _ => unreachable!(),
1706 }
1707 }
1708 let api_that_guard = api_that_guard.unwrap();
1709 let output_ok =
1710 crate::bindings::BindingLiquidSdk::sign_message(&*api_that_guard, api_req)?;
1711 Ok(output_ok)
1712 })())
1713 },
1714 )
1715}
1716fn wire__crate__bindings__BindingLiquidSdk_sync_impl(
1717 port_: flutter_rust_bridge::for_generated::MessagePort,
1718 that: impl CstDecode<
1719 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1720 >,
1721) {
1722 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1723 flutter_rust_bridge::for_generated::TaskInfo {
1724 debug_name: "BindingLiquidSdk_sync(dart_style=sync)",
1725 port: Some(port_),
1726 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1727 },
1728 move || {
1729 let api_that = that.cst_decode();
1730 move |context| async move {
1731 transform_result_dco::<_, _, crate::error::SdkError>(
1732 (move || async move {
1733 let mut api_that_guard = None;
1734 let decode_indices_ =
1735 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1736 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1737 &api_that, 0, false,
1738 )],
1739 );
1740 for i in decode_indices_ {
1741 match i {
1742 0 => {
1743 api_that_guard =
1744 Some(api_that.lockable_decode_async_ref().await)
1745 }
1746 _ => unreachable!(),
1747 }
1748 }
1749 let api_that_guard = api_that_guard.unwrap();
1750 let output_ok =
1751 crate::bindings::BindingLiquidSdk::sync(&*api_that_guard).await?;
1752 Ok(output_ok)
1753 })()
1754 .await,
1755 )
1756 }
1757 },
1758 )
1759}
1760fn wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(
1761 port_: flutter_rust_bridge::for_generated::MessagePort,
1762 that: impl CstDecode<
1763 RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1764 >,
1765) {
1766 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1767 flutter_rust_bridge::for_generated::TaskInfo {
1768 debug_name: "BindingLiquidSdk_unregister_webhook",
1769 port: Some(port_),
1770 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1771 },
1772 move || {
1773 let api_that = that.cst_decode();
1774 move |context| async move {
1775 transform_result_dco::<_, _, crate::error::SdkError>(
1776 (move || async move {
1777 let mut api_that_guard = None;
1778 let decode_indices_ =
1779 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1780 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1781 &api_that, 0, false,
1782 )],
1783 );
1784 for i in decode_indices_ {
1785 match i {
1786 0 => {
1787 api_that_guard =
1788 Some(api_that.lockable_decode_async_ref().await)
1789 }
1790 _ => unreachable!(),
1791 }
1792 }
1793 let api_that_guard = api_that_guard.unwrap();
1794 let output_ok =
1795 crate::bindings::BindingLiquidSdk::unregister_webhook(&*api_that_guard)
1796 .await?;
1797 Ok(output_ok)
1798 })()
1799 .await,
1800 )
1801 }
1802 },
1803 )
1804}
1805fn wire__crate__bindings__binding_event_listener_on_event_impl(
1806 port_: flutter_rust_bridge::for_generated::MessagePort,
1807 that: impl CstDecode<crate::bindings::BindingEventListener>,
1808 e: impl CstDecode<crate::model::SdkEvent>,
1809) {
1810 FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
1811 flutter_rust_bridge::for_generated::TaskInfo {
1812 debug_name: "binding_event_listener_on_event",
1813 port: Some(port_),
1814 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1815 },
1816 move || {
1817 let api_that = that.cst_decode();
1818 let api_e = e.cst_decode();
1819 move |context| {
1820 transform_result_dco::<_, _, ()>((move || {
1821 let output_ok = Result::<_, ()>::Ok({
1822 crate::bindings::BindingEventListener::on_event(&api_that, api_e);
1823 })?;
1824 Ok(output_ok)
1825 })())
1826 }
1827 },
1828 )
1829}
1830fn wire__crate__bindings__breez_log_stream_impl(
1831 port_: flutter_rust_bridge::for_generated::MessagePort,
1832 s: impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>,
1833) {
1834 FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
1835 flutter_rust_bridge::for_generated::TaskInfo {
1836 debug_name: "breez_log_stream",
1837 port: Some(port_),
1838 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1839 },
1840 move || {
1841 let api_s = s.cst_decode();
1842 move |context| {
1843 transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
1844 (move || {
1845 let output_ok = crate::bindings::breez_log_stream(api_s)?;
1846 Ok(output_ok)
1847 })(),
1848 )
1849 }
1850 },
1851 )
1852}
1853fn wire__crate__bindings__connect_impl(
1854 port_: flutter_rust_bridge::for_generated::MessagePort,
1855 req: impl CstDecode<crate::model::ConnectRequest>,
1856) {
1857 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1858 flutter_rust_bridge::for_generated::TaskInfo {
1859 debug_name: "connect",
1860 port: Some(port_),
1861 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1862 },
1863 move || {
1864 let api_req = req.cst_decode();
1865 move |context| async move {
1866 transform_result_dco::<_, _, crate::error::SdkError>(
1867 (move || async move {
1868 let output_ok = crate::bindings::connect(api_req).await?;
1869 Ok(output_ok)
1870 })()
1871 .await,
1872 )
1873 }
1874 },
1875 )
1876}
1877fn wire__crate__bindings__default_config_impl(
1878 network: impl CstDecode<crate::model::LiquidNetwork>,
1879 breez_api_key: impl CstDecode<Option<String>>,
1880) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1881 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1882 flutter_rust_bridge::for_generated::TaskInfo {
1883 debug_name: "default_config",
1884 port: None,
1885 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1886 },
1887 move || {
1888 let api_network = network.cst_decode();
1889 let api_breez_api_key = breez_api_key.cst_decode();
1890 transform_result_dco::<_, _, crate::error::SdkError>((move || {
1891 let output_ok = crate::bindings::default_config(api_network, api_breez_api_key)?;
1892 Ok(output_ok)
1893 })())
1894 },
1895 )
1896}
1897fn wire__crate__bindings__parse_invoice_impl(
1898 input: impl CstDecode<String>,
1899) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1900 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1901 flutter_rust_bridge::for_generated::TaskInfo {
1902 debug_name: "parse_invoice",
1903 port: None,
1904 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1905 },
1906 move || {
1907 let api_input = input.cst_decode();
1908 transform_result_dco::<_, _, crate::error::PaymentError>((move || {
1909 let output_ok = crate::bindings::parse_invoice(api_input)?;
1910 Ok(output_ok)
1911 })())
1912 },
1913 )
1914}
1915
1916#[allow(clippy::unnecessary_literal_unwrap)]
1919const _: fn() = || {
1920 {
1921 let AesSuccessActionData = None::<crate::bindings::AesSuccessActionData>.unwrap();
1922 let _: String = AesSuccessActionData.description;
1923 let _: String = AesSuccessActionData.ciphertext;
1924 let _: String = AesSuccessActionData.iv;
1925 }
1926 {
1927 let AesSuccessActionDataDecrypted =
1928 None::<crate::bindings::AesSuccessActionDataDecrypted>.unwrap();
1929 let _: String = AesSuccessActionDataDecrypted.description;
1930 let _: String = AesSuccessActionDataDecrypted.plaintext;
1931 }
1932 match None::<crate::bindings::AesSuccessActionDataResult>.unwrap() {
1933 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
1934 let _: crate::bindings::AesSuccessActionDataDecrypted = data;
1935 }
1936 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
1937 let _: String = reason;
1938 }
1939 }
1940 match None::<crate::bindings::Amount>.unwrap() {
1941 crate::bindings::Amount::Bitcoin { amount_msat } => {
1942 let _: u64 = amount_msat;
1943 }
1944 crate::bindings::Amount::Currency {
1945 iso4217_code,
1946 fractional_amount,
1947 } => {
1948 let _: String = iso4217_code;
1949 let _: u64 = fractional_amount;
1950 }
1951 }
1952 {
1953 let BitcoinAddressData = None::<crate::bindings::BitcoinAddressData>.unwrap();
1954 let _: String = BitcoinAddressData.address;
1955 let _: crate::bindings::Network = BitcoinAddressData.network;
1956 let _: Option<u64> = BitcoinAddressData.amount_sat;
1957 let _: Option<String> = BitcoinAddressData.label;
1958 let _: Option<String> = BitcoinAddressData.message;
1959 }
1960 {
1961 let CurrencyInfo = None::<crate::bindings::CurrencyInfo>.unwrap();
1962 let _: String = CurrencyInfo.name;
1963 let _: u32 = CurrencyInfo.fraction_size;
1964 let _: Option<u32> = CurrencyInfo.spacing;
1965 let _: Option<crate::bindings::Symbol> = CurrencyInfo.symbol;
1966 let _: Option<crate::bindings::Symbol> = CurrencyInfo.uniq_symbol;
1967 let _: Vec<crate::bindings::LocalizedName> = CurrencyInfo.localized_name;
1968 let _: Vec<crate::bindings::LocaleOverrides> = CurrencyInfo.locale_overrides;
1969 }
1970 {
1971 let ExternalInputParser = None::<crate::bindings::ExternalInputParser>.unwrap();
1972 let _: String = ExternalInputParser.provider_id;
1973 let _: String = ExternalInputParser.input_regex;
1974 let _: String = ExternalInputParser.parser_url;
1975 }
1976 {
1977 let FiatCurrency = None::<crate::bindings::FiatCurrency>.unwrap();
1978 let _: String = FiatCurrency.id;
1979 let _: crate::bindings::CurrencyInfo = FiatCurrency.info;
1980 }
1981 match None::<crate::bindings::InputType>.unwrap() {
1982 crate::bindings::InputType::BitcoinAddress { address } => {
1983 let _: crate::bindings::BitcoinAddressData = address;
1984 }
1985 crate::bindings::InputType::LiquidAddress { address } => {
1986 let _: crate::bindings::LiquidAddressData = address;
1987 }
1988 crate::bindings::InputType::Bolt11 { invoice } => {
1989 let _: crate::bindings::LNInvoice = invoice;
1990 }
1991 crate::bindings::InputType::Bolt12Offer {
1992 offer,
1993 bip353_address,
1994 } => {
1995 let _: crate::bindings::LNOffer = offer;
1996 let _: Option<String> = bip353_address;
1997 }
1998 crate::bindings::InputType::NodeId { node_id } => {
1999 let _: String = node_id;
2000 }
2001 crate::bindings::InputType::Url { url } => {
2002 let _: String = url;
2003 }
2004 crate::bindings::InputType::LnUrlPay {
2005 data,
2006 bip353_address,
2007 } => {
2008 let _: crate::bindings::LnUrlPayRequestData = data;
2009 let _: Option<String> = bip353_address;
2010 }
2011 crate::bindings::InputType::LnUrlWithdraw { data } => {
2012 let _: crate::bindings::LnUrlWithdrawRequestData = data;
2013 }
2014 crate::bindings::InputType::LnUrlAuth { data } => {
2015 let _: crate::bindings::LnUrlAuthRequestData = data;
2016 }
2017 crate::bindings::InputType::LnUrlError { data } => {
2018 let _: crate::bindings::LnUrlErrorData = data;
2019 }
2020 }
2021 {
2022 let LiquidAddressData = None::<crate::bindings::LiquidAddressData>.unwrap();
2023 let _: String = LiquidAddressData.address;
2024 let _: crate::bindings::Network = LiquidAddressData.network;
2025 let _: Option<String> = LiquidAddressData.asset_id;
2026 let _: Option<f64> = LiquidAddressData.amount;
2027 let _: Option<u64> = LiquidAddressData.amount_sat;
2028 let _: Option<String> = LiquidAddressData.label;
2029 let _: Option<String> = LiquidAddressData.message;
2030 }
2031 {
2032 let LNInvoice = None::<crate::bindings::LNInvoice>.unwrap();
2033 let _: String = LNInvoice.bolt11;
2034 let _: crate::bindings::Network = LNInvoice.network;
2035 let _: String = LNInvoice.payee_pubkey;
2036 let _: String = LNInvoice.payment_hash;
2037 let _: Option<String> = LNInvoice.description;
2038 let _: Option<String> = LNInvoice.description_hash;
2039 let _: Option<u64> = LNInvoice.amount_msat;
2040 let _: u64 = LNInvoice.timestamp;
2041 let _: u64 = LNInvoice.expiry;
2042 let _: Vec<crate::bindings::RouteHint> = LNInvoice.routing_hints;
2043 let _: Vec<u8> = LNInvoice.payment_secret;
2044 let _: u64 = LNInvoice.min_final_cltv_expiry_delta;
2045 }
2046 {
2047 let LNOffer = None::<crate::bindings::LNOffer>.unwrap();
2048 let _: String = LNOffer.offer;
2049 let _: Vec<String> = LNOffer.chains;
2050 let _: Option<crate::bindings::Amount> = LNOffer.min_amount;
2051 let _: Option<String> = LNOffer.description;
2052 let _: Option<u64> = LNOffer.absolute_expiry;
2053 let _: Option<String> = LNOffer.issuer;
2054 let _: Option<String> = LNOffer.signing_pubkey;
2055 let _: Vec<crate::bindings::LnOfferBlindedPath> = LNOffer.paths;
2056 }
2057 {
2058 let LnOfferBlindedPath = None::<crate::bindings::LnOfferBlindedPath>.unwrap();
2059 let _: Vec<String> = LnOfferBlindedPath.blinded_hops;
2060 }
2061 {
2062 let LnUrlAuthRequestData = None::<crate::bindings::LnUrlAuthRequestData>.unwrap();
2063 let _: String = LnUrlAuthRequestData.k1;
2064 let _: Option<String> = LnUrlAuthRequestData.action;
2065 let _: String = LnUrlAuthRequestData.domain;
2066 let _: String = LnUrlAuthRequestData.url;
2067 }
2068 {
2069 let LnUrlErrorData = None::<crate::bindings::LnUrlErrorData>.unwrap();
2070 let _: String = LnUrlErrorData.reason;
2071 }
2072 {
2073 let LnUrlPayErrorData = None::<crate::bindings::LnUrlPayErrorData>.unwrap();
2074 let _: String = LnUrlPayErrorData.payment_hash;
2075 let _: String = LnUrlPayErrorData.reason;
2076 }
2077 {
2078 let LnUrlPayRequestData = None::<crate::bindings::LnUrlPayRequestData>.unwrap();
2079 let _: String = LnUrlPayRequestData.callback;
2080 let _: u64 = LnUrlPayRequestData.min_sendable;
2081 let _: u64 = LnUrlPayRequestData.max_sendable;
2082 let _: String = LnUrlPayRequestData.metadata_str;
2083 let _: u16 = LnUrlPayRequestData.comment_allowed;
2084 let _: String = LnUrlPayRequestData.domain;
2085 let _: bool = LnUrlPayRequestData.allows_nostr;
2086 let _: Option<String> = LnUrlPayRequestData.nostr_pubkey;
2087 let _: Option<String> = LnUrlPayRequestData.ln_address;
2088 }
2089 {
2090 let LnUrlWithdrawRequest = None::<crate::bindings::LnUrlWithdrawRequest>.unwrap();
2091 let _: crate::bindings::LnUrlWithdrawRequestData = LnUrlWithdrawRequest.data;
2092 let _: u64 = LnUrlWithdrawRequest.amount_msat;
2093 let _: Option<String> = LnUrlWithdrawRequest.description;
2094 }
2095 {
2096 let LnUrlWithdrawRequestData = None::<crate::bindings::LnUrlWithdrawRequestData>.unwrap();
2097 let _: String = LnUrlWithdrawRequestData.callback;
2098 let _: String = LnUrlWithdrawRequestData.k1;
2099 let _: String = LnUrlWithdrawRequestData.default_description;
2100 let _: u64 = LnUrlWithdrawRequestData.min_withdrawable;
2101 let _: u64 = LnUrlWithdrawRequestData.max_withdrawable;
2102 }
2103 {
2104 let LocaleOverrides = None::<crate::bindings::LocaleOverrides>.unwrap();
2105 let _: String = LocaleOverrides.locale;
2106 let _: Option<u32> = LocaleOverrides.spacing;
2107 let _: crate::bindings::Symbol = LocaleOverrides.symbol;
2108 }
2109 {
2110 let LocalizedName = None::<crate::bindings::LocalizedName>.unwrap();
2111 let _: String = LocalizedName.locale;
2112 let _: String = LocalizedName.name;
2113 }
2114 {
2115 let MessageSuccessActionData = None::<crate::bindings::MessageSuccessActionData>.unwrap();
2116 let _: String = MessageSuccessActionData.message;
2117 }
2118 {
2119 let Rate = None::<crate::bindings::Rate>.unwrap();
2120 let _: String = Rate.coin;
2121 let _: f64 = Rate.value;
2122 }
2123 {
2124 let RouteHint = None::<crate::bindings::RouteHint>.unwrap();
2125 let _: Vec<crate::bindings::RouteHintHop> = RouteHint.hops;
2126 }
2127 {
2128 let RouteHintHop = None::<crate::bindings::RouteHintHop>.unwrap();
2129 let _: String = RouteHintHop.src_node_id;
2130 let _: String = RouteHintHop.short_channel_id;
2131 let _: u32 = RouteHintHop.fees_base_msat;
2132 let _: u32 = RouteHintHop.fees_proportional_millionths;
2133 let _: u64 = RouteHintHop.cltv_expiry_delta;
2134 let _: Option<u64> = RouteHintHop.htlc_minimum_msat;
2135 let _: Option<u64> = RouteHintHop.htlc_maximum_msat;
2136 }
2137 match None::<crate::bindings::SuccessAction>.unwrap() {
2138 crate::bindings::SuccessAction::Aes { data } => {
2139 let _: crate::bindings::AesSuccessActionData = data;
2140 }
2141 crate::bindings::SuccessAction::Message { data } => {
2142 let _: crate::bindings::MessageSuccessActionData = data;
2143 }
2144 crate::bindings::SuccessAction::Url { data } => {
2145 let _: crate::bindings::UrlSuccessActionData = data;
2146 }
2147 }
2148 match None::<crate::bindings::SuccessActionProcessed>.unwrap() {
2149 crate::bindings::SuccessActionProcessed::Aes { result } => {
2150 let _: crate::bindings::AesSuccessActionDataResult = result;
2151 }
2152 crate::bindings::SuccessActionProcessed::Message { data } => {
2153 let _: crate::bindings::MessageSuccessActionData = data;
2154 }
2155 crate::bindings::SuccessActionProcessed::Url { data } => {
2156 let _: crate::bindings::UrlSuccessActionData = data;
2157 }
2158 }
2159 {
2160 let Symbol = None::<crate::bindings::Symbol>.unwrap();
2161 let _: Option<String> = Symbol.grapheme;
2162 let _: Option<String> = Symbol.template;
2163 let _: Option<bool> = Symbol.rtl;
2164 let _: Option<u32> = Symbol.position;
2165 }
2166 {
2167 let UrlSuccessActionData = None::<crate::bindings::UrlSuccessActionData>.unwrap();
2168 let _: String = UrlSuccessActionData.description;
2169 let _: String = UrlSuccessActionData.url;
2170 let _: bool = UrlSuccessActionData.matches_callback_domain;
2171 }
2172};
2173
2174impl CstDecode<bool> for bool {
2177 fn cst_decode(self) -> bool {
2179 self
2180 }
2181}
2182impl CstDecode<crate::model::BuyBitcoinProvider> for i32 {
2183 fn cst_decode(self) -> crate::model::BuyBitcoinProvider {
2185 match self {
2186 0 => crate::model::BuyBitcoinProvider::Moonpay,
2187 _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", self),
2188 }
2189 }
2190}
2191impl CstDecode<f64> for f64 {
2192 fn cst_decode(self) -> f64 {
2194 self
2195 }
2196}
2197impl CstDecode<i32> for i32 {
2198 fn cst_decode(self) -> i32 {
2200 self
2201 }
2202}
2203impl CstDecode<i64> for i64 {
2204 fn cst_decode(self) -> i64 {
2206 self
2207 }
2208}
2209impl CstDecode<crate::model::LiquidNetwork> for i32 {
2210 fn cst_decode(self) -> crate::model::LiquidNetwork {
2212 match self {
2213 0 => crate::model::LiquidNetwork::Mainnet,
2214 1 => crate::model::LiquidNetwork::Testnet,
2215 2 => crate::model::LiquidNetwork::Regtest,
2216 _ => unreachable!("Invalid variant for LiquidNetwork: {}", self),
2217 }
2218 }
2219}
2220impl CstDecode<crate::bindings::Network> for i32 {
2221 fn cst_decode(self) -> crate::bindings::Network {
2223 match self {
2224 0 => crate::bindings::Network::Bitcoin,
2225 1 => crate::bindings::Network::Testnet,
2226 2 => crate::bindings::Network::Signet,
2227 3 => crate::bindings::Network::Regtest,
2228 _ => unreachable!("Invalid variant for Network: {}", self),
2229 }
2230 }
2231}
2232impl CstDecode<crate::model::PaymentMethod> for i32 {
2233 fn cst_decode(self) -> crate::model::PaymentMethod {
2235 match self {
2236 0 => crate::model::PaymentMethod::Lightning,
2237 1 => crate::model::PaymentMethod::Bolt11Invoice,
2238 2 => crate::model::PaymentMethod::Bolt12Offer,
2239 3 => crate::model::PaymentMethod::BitcoinAddress,
2240 4 => crate::model::PaymentMethod::LiquidAddress,
2241 _ => unreachable!("Invalid variant for PaymentMethod: {}", self),
2242 }
2243 }
2244}
2245impl CstDecode<crate::model::PaymentState> for i32 {
2246 fn cst_decode(self) -> crate::model::PaymentState {
2248 match self {
2249 0 => crate::model::PaymentState::Created,
2250 1 => crate::model::PaymentState::Pending,
2251 2 => crate::model::PaymentState::Complete,
2252 3 => crate::model::PaymentState::Failed,
2253 4 => crate::model::PaymentState::TimedOut,
2254 5 => crate::model::PaymentState::Refundable,
2255 6 => crate::model::PaymentState::RefundPending,
2256 7 => crate::model::PaymentState::WaitingFeeAcceptance,
2257 _ => unreachable!("Invalid variant for PaymentState: {}", self),
2258 }
2259 }
2260}
2261impl CstDecode<crate::model::PaymentType> for i32 {
2262 fn cst_decode(self) -> crate::model::PaymentType {
2264 match self {
2265 0 => crate::model::PaymentType::Receive,
2266 1 => crate::model::PaymentType::Send,
2267 _ => unreachable!("Invalid variant for PaymentType: {}", self),
2268 }
2269 }
2270}
2271impl CstDecode<u16> for u16 {
2272 fn cst_decode(self) -> u16 {
2274 self
2275 }
2276}
2277impl CstDecode<u32> for u32 {
2278 fn cst_decode(self) -> u32 {
2280 self
2281 }
2282}
2283impl CstDecode<u64> for u64 {
2284 fn cst_decode(self) -> u64 {
2286 self
2287 }
2288}
2289impl CstDecode<u8> for u8 {
2290 fn cst_decode(self) -> u8 {
2292 self
2293 }
2294}
2295impl CstDecode<usize> for usize {
2296 fn cst_decode(self) -> usize {
2298 self
2299 }
2300}
2301impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
2302 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2304 let mut inner = <String>::sse_decode(deserializer);
2305 return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
2306 }
2307}
2308
2309impl SseDecode for BindingLiquidSdk {
2310 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2312 let mut inner = <RustOpaqueNom<
2313 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
2314 >>::sse_decode(deserializer);
2315 return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
2316 }
2317}
2318
2319impl SseDecode
2320 for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
2321{
2322 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2324 let mut inner = <usize>::sse_decode(deserializer);
2325 return unsafe { decode_rust_opaque_nom(inner) };
2326 }
2327}
2328
2329impl SseDecode
2330 for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
2331{
2332 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2334 let mut inner = <String>::sse_decode(deserializer);
2335 return StreamSink::deserialize(inner);
2336 }
2337}
2338
2339impl SseDecode
2340 for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
2341{
2342 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2344 let mut inner = <String>::sse_decode(deserializer);
2345 return StreamSink::deserialize(inner);
2346 }
2347}
2348
2349impl SseDecode for String {
2350 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2352 let mut inner = <Vec<u8>>::sse_decode(deserializer);
2353 return String::from_utf8(inner).unwrap();
2354 }
2355}
2356
2357impl SseDecode for crate::model::AcceptPaymentProposedFeesRequest {
2358 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2360 let mut var_response =
2361 <crate::model::FetchPaymentProposedFeesResponse>::sse_decode(deserializer);
2362 return crate::model::AcceptPaymentProposedFeesRequest {
2363 response: var_response,
2364 };
2365 }
2366}
2367
2368impl SseDecode for crate::bindings::AesSuccessActionData {
2369 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2371 let mut var_description = <String>::sse_decode(deserializer);
2372 let mut var_ciphertext = <String>::sse_decode(deserializer);
2373 let mut var_iv = <String>::sse_decode(deserializer);
2374 return crate::bindings::AesSuccessActionData {
2375 description: var_description,
2376 ciphertext: var_ciphertext,
2377 iv: var_iv,
2378 };
2379 }
2380}
2381
2382impl SseDecode for crate::bindings::AesSuccessActionDataDecrypted {
2383 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2385 let mut var_description = <String>::sse_decode(deserializer);
2386 let mut var_plaintext = <String>::sse_decode(deserializer);
2387 return crate::bindings::AesSuccessActionDataDecrypted {
2388 description: var_description,
2389 plaintext: var_plaintext,
2390 };
2391 }
2392}
2393
2394impl SseDecode for crate::bindings::AesSuccessActionDataResult {
2395 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2397 let mut tag_ = <i32>::sse_decode(deserializer);
2398 match tag_ {
2399 0 => {
2400 let mut var_data =
2401 <crate::bindings::AesSuccessActionDataDecrypted>::sse_decode(deserializer);
2402 return crate::bindings::AesSuccessActionDataResult::Decrypted { data: var_data };
2403 }
2404 1 => {
2405 let mut var_reason = <String>::sse_decode(deserializer);
2406 return crate::bindings::AesSuccessActionDataResult::ErrorStatus {
2407 reason: var_reason,
2408 };
2409 }
2410 _ => {
2411 unimplemented!("");
2412 }
2413 }
2414 }
2415}
2416
2417impl SseDecode for crate::bindings::Amount {
2418 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2420 let mut tag_ = <i32>::sse_decode(deserializer);
2421 match tag_ {
2422 0 => {
2423 let mut var_amountMsat = <u64>::sse_decode(deserializer);
2424 return crate::bindings::Amount::Bitcoin {
2425 amount_msat: var_amountMsat,
2426 };
2427 }
2428 1 => {
2429 let mut var_iso4217Code = <String>::sse_decode(deserializer);
2430 let mut var_fractionalAmount = <u64>::sse_decode(deserializer);
2431 return crate::bindings::Amount::Currency {
2432 iso4217_code: var_iso4217Code,
2433 fractional_amount: var_fractionalAmount,
2434 };
2435 }
2436 _ => {
2437 unimplemented!("");
2438 }
2439 }
2440 }
2441}
2442
2443impl SseDecode for crate::model::AssetBalance {
2444 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2446 let mut var_assetId = <String>::sse_decode(deserializer);
2447 let mut var_balanceSat = <u64>::sse_decode(deserializer);
2448 let mut var_name = <Option<String>>::sse_decode(deserializer);
2449 let mut var_ticker = <Option<String>>::sse_decode(deserializer);
2450 let mut var_balance = <Option<f64>>::sse_decode(deserializer);
2451 return crate::model::AssetBalance {
2452 asset_id: var_assetId,
2453 balance_sat: var_balanceSat,
2454 name: var_name,
2455 ticker: var_ticker,
2456 balance: var_balance,
2457 };
2458 }
2459}
2460
2461impl SseDecode for crate::model::AssetInfo {
2462 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2464 let mut var_name = <String>::sse_decode(deserializer);
2465 let mut var_ticker = <String>::sse_decode(deserializer);
2466 let mut var_amount = <f64>::sse_decode(deserializer);
2467 let mut var_fees = <Option<f64>>::sse_decode(deserializer);
2468 return crate::model::AssetInfo {
2469 name: var_name,
2470 ticker: var_ticker,
2471 amount: var_amount,
2472 fees: var_fees,
2473 };
2474 }
2475}
2476
2477impl SseDecode for crate::model::AssetMetadata {
2478 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2480 let mut var_assetId = <String>::sse_decode(deserializer);
2481 let mut var_name = <String>::sse_decode(deserializer);
2482 let mut var_ticker = <String>::sse_decode(deserializer);
2483 let mut var_precision = <u8>::sse_decode(deserializer);
2484 let mut var_fiatId = <Option<String>>::sse_decode(deserializer);
2485 return crate::model::AssetMetadata {
2486 asset_id: var_assetId,
2487 name: var_name,
2488 ticker: var_ticker,
2489 precision: var_precision,
2490 fiat_id: var_fiatId,
2491 };
2492 }
2493}
2494
2495impl SseDecode for crate::model::BackupRequest {
2496 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2498 let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
2499 return crate::model::BackupRequest {
2500 backup_path: var_backupPath,
2501 };
2502 }
2503}
2504
2505impl SseDecode for crate::bindings::BindingEventListener {
2506 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2508 let mut var_stream = <StreamSink<
2509 crate::model::SdkEvent,
2510 flutter_rust_bridge::for_generated::DcoCodec,
2511 >>::sse_decode(deserializer);
2512 return crate::bindings::BindingEventListener { stream: var_stream };
2513 }
2514}
2515
2516impl SseDecode for crate::bindings::BitcoinAddressData {
2517 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2519 let mut var_address = <String>::sse_decode(deserializer);
2520 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2521 let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2522 let mut var_label = <Option<String>>::sse_decode(deserializer);
2523 let mut var_message = <Option<String>>::sse_decode(deserializer);
2524 return crate::bindings::BitcoinAddressData {
2525 address: var_address,
2526 network: var_network,
2527 amount_sat: var_amountSat,
2528 label: var_label,
2529 message: var_message,
2530 };
2531 }
2532}
2533
2534impl SseDecode for crate::model::BlockchainExplorer {
2535 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2537 let mut tag_ = <i32>::sse_decode(deserializer);
2538 match tag_ {
2539 0 => {
2540 let mut var_url = <String>::sse_decode(deserializer);
2541 return crate::model::BlockchainExplorer::Electrum { url: var_url };
2542 }
2543 1 => {
2544 let mut var_url = <String>::sse_decode(deserializer);
2545 let mut var_useWaterfalls = <bool>::sse_decode(deserializer);
2546 return crate::model::BlockchainExplorer::Esplora {
2547 url: var_url,
2548 use_waterfalls: var_useWaterfalls,
2549 };
2550 }
2551 _ => {
2552 unimplemented!("");
2553 }
2554 }
2555 }
2556}
2557
2558impl SseDecode for crate::model::BlockchainInfo {
2559 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2561 let mut var_liquidTip = <u32>::sse_decode(deserializer);
2562 let mut var_bitcoinTip = <u32>::sse_decode(deserializer);
2563 return crate::model::BlockchainInfo {
2564 liquid_tip: var_liquidTip,
2565 bitcoin_tip: var_bitcoinTip,
2566 };
2567 }
2568}
2569
2570impl SseDecode for bool {
2571 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2573 deserializer.cursor.read_u8().unwrap() != 0
2574 }
2575}
2576
2577impl SseDecode for crate::model::BuyBitcoinProvider {
2578 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2580 let mut inner = <i32>::sse_decode(deserializer);
2581 return match inner {
2582 0 => crate::model::BuyBitcoinProvider::Moonpay,
2583 _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", inner),
2584 };
2585 }
2586}
2587
2588impl SseDecode for crate::model::BuyBitcoinRequest {
2589 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2591 let mut var_prepareResponse =
2592 <crate::model::PrepareBuyBitcoinResponse>::sse_decode(deserializer);
2593 let mut var_redirectUrl = <Option<String>>::sse_decode(deserializer);
2594 return crate::model::BuyBitcoinRequest {
2595 prepare_response: var_prepareResponse,
2596 redirect_url: var_redirectUrl,
2597 };
2598 }
2599}
2600
2601impl SseDecode for crate::model::CheckMessageRequest {
2602 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2604 let mut var_message = <String>::sse_decode(deserializer);
2605 let mut var_pubkey = <String>::sse_decode(deserializer);
2606 let mut var_signature = <String>::sse_decode(deserializer);
2607 return crate::model::CheckMessageRequest {
2608 message: var_message,
2609 pubkey: var_pubkey,
2610 signature: var_signature,
2611 };
2612 }
2613}
2614
2615impl SseDecode for crate::model::CheckMessageResponse {
2616 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2618 let mut var_isValid = <bool>::sse_decode(deserializer);
2619 return crate::model::CheckMessageResponse {
2620 is_valid: var_isValid,
2621 };
2622 }
2623}
2624
2625impl SseDecode for crate::model::Config {
2626 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2628 let mut var_liquidExplorer = <crate::model::BlockchainExplorer>::sse_decode(deserializer);
2629 let mut var_bitcoinExplorer = <crate::model::BlockchainExplorer>::sse_decode(deserializer);
2630 let mut var_workingDir = <String>::sse_decode(deserializer);
2631 let mut var_network = <crate::model::LiquidNetwork>::sse_decode(deserializer);
2632 let mut var_paymentTimeoutSec = <u64>::sse_decode(deserializer);
2633 let mut var_syncServiceUrl = <Option<String>>::sse_decode(deserializer);
2634 let mut var_zeroConfMaxAmountSat = <Option<u64>>::sse_decode(deserializer);
2635 let mut var_breezApiKey = <Option<String>>::sse_decode(deserializer);
2636 let mut var_externalInputParsers =
2637 <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_decode(deserializer);
2638 let mut var_useDefaultExternalInputParsers = <bool>::sse_decode(deserializer);
2639 let mut var_onchainFeeRateLeewaySat = <Option<u64>>::sse_decode(deserializer);
2640 let mut var_assetMetadata =
2641 <Option<Vec<crate::model::AssetMetadata>>>::sse_decode(deserializer);
2642 let mut var_sideswapApiKey = <Option<String>>::sse_decode(deserializer);
2643 return crate::model::Config {
2644 liquid_explorer: var_liquidExplorer,
2645 bitcoin_explorer: var_bitcoinExplorer,
2646 working_dir: var_workingDir,
2647 network: var_network,
2648 payment_timeout_sec: var_paymentTimeoutSec,
2649 sync_service_url: var_syncServiceUrl,
2650 zero_conf_max_amount_sat: var_zeroConfMaxAmountSat,
2651 breez_api_key: var_breezApiKey,
2652 external_input_parsers: var_externalInputParsers,
2653 use_default_external_input_parsers: var_useDefaultExternalInputParsers,
2654 onchain_fee_rate_leeway_sat: var_onchainFeeRateLeewaySat,
2655 asset_metadata: var_assetMetadata,
2656 sideswap_api_key: var_sideswapApiKey,
2657 };
2658 }
2659}
2660
2661impl SseDecode for crate::model::ConnectRequest {
2662 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2664 let mut var_config = <crate::model::Config>::sse_decode(deserializer);
2665 let mut var_mnemonic = <Option<String>>::sse_decode(deserializer);
2666 let mut var_passphrase = <Option<String>>::sse_decode(deserializer);
2667 let mut var_seed = <Option<Vec<u8>>>::sse_decode(deserializer);
2668 return crate::model::ConnectRequest {
2669 config: var_config,
2670 mnemonic: var_mnemonic,
2671 passphrase: var_passphrase,
2672 seed: var_seed,
2673 };
2674 }
2675}
2676
2677impl SseDecode for crate::model::CreateBolt12InvoiceRequest {
2678 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2680 let mut var_offer = <String>::sse_decode(deserializer);
2681 let mut var_invoiceRequest = <String>::sse_decode(deserializer);
2682 return crate::model::CreateBolt12InvoiceRequest {
2683 offer: var_offer,
2684 invoice_request: var_invoiceRequest,
2685 };
2686 }
2687}
2688
2689impl SseDecode for crate::model::CreateBolt12InvoiceResponse {
2690 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2692 let mut var_invoice = <String>::sse_decode(deserializer);
2693 return crate::model::CreateBolt12InvoiceResponse {
2694 invoice: var_invoice,
2695 };
2696 }
2697}
2698
2699impl SseDecode for crate::bindings::CurrencyInfo {
2700 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2702 let mut var_name = <String>::sse_decode(deserializer);
2703 let mut var_fractionSize = <u32>::sse_decode(deserializer);
2704 let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
2705 let mut var_symbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2706 let mut var_uniqSymbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2707 let mut var_localizedName = <Vec<crate::bindings::LocalizedName>>::sse_decode(deserializer);
2708 let mut var_localeOverrides =
2709 <Vec<crate::bindings::LocaleOverrides>>::sse_decode(deserializer);
2710 return crate::bindings::CurrencyInfo {
2711 name: var_name,
2712 fraction_size: var_fractionSize,
2713 spacing: var_spacing,
2714 symbol: var_symbol,
2715 uniq_symbol: var_uniqSymbol,
2716 localized_name: var_localizedName,
2717 locale_overrides: var_localeOverrides,
2718 };
2719 }
2720}
2721
2722impl SseDecode for crate::bindings::ExternalInputParser {
2723 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2725 let mut var_providerId = <String>::sse_decode(deserializer);
2726 let mut var_inputRegex = <String>::sse_decode(deserializer);
2727 let mut var_parserUrl = <String>::sse_decode(deserializer);
2728 return crate::bindings::ExternalInputParser {
2729 provider_id: var_providerId,
2730 input_regex: var_inputRegex,
2731 parser_url: var_parserUrl,
2732 };
2733 }
2734}
2735
2736impl SseDecode for f64 {
2737 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2739 deserializer.cursor.read_f64::<NativeEndian>().unwrap()
2740 }
2741}
2742
2743impl SseDecode for crate::model::FetchPaymentProposedFeesRequest {
2744 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2746 let mut var_swapId = <String>::sse_decode(deserializer);
2747 return crate::model::FetchPaymentProposedFeesRequest {
2748 swap_id: var_swapId,
2749 };
2750 }
2751}
2752
2753impl SseDecode for crate::model::FetchPaymentProposedFeesResponse {
2754 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2756 let mut var_swapId = <String>::sse_decode(deserializer);
2757 let mut var_feesSat = <u64>::sse_decode(deserializer);
2758 let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
2759 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
2760 return crate::model::FetchPaymentProposedFeesResponse {
2761 swap_id: var_swapId,
2762 fees_sat: var_feesSat,
2763 payer_amount_sat: var_payerAmountSat,
2764 receiver_amount_sat: var_receiverAmountSat,
2765 };
2766 }
2767}
2768
2769impl SseDecode for crate::bindings::FiatCurrency {
2770 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2772 let mut var_id = <String>::sse_decode(deserializer);
2773 let mut var_info = <crate::bindings::CurrencyInfo>::sse_decode(deserializer);
2774 return crate::bindings::FiatCurrency {
2775 id: var_id,
2776 info: var_info,
2777 };
2778 }
2779}
2780
2781impl SseDecode for crate::model::GetInfoResponse {
2782 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2784 let mut var_walletInfo = <crate::model::WalletInfo>::sse_decode(deserializer);
2785 let mut var_blockchainInfo = <crate::model::BlockchainInfo>::sse_decode(deserializer);
2786 return crate::model::GetInfoResponse {
2787 wallet_info: var_walletInfo,
2788 blockchain_info: var_blockchainInfo,
2789 };
2790 }
2791}
2792
2793impl SseDecode for crate::model::GetPaymentRequest {
2794 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2796 let mut tag_ = <i32>::sse_decode(deserializer);
2797 match tag_ {
2798 0 => {
2799 let mut var_paymentHash = <String>::sse_decode(deserializer);
2800 return crate::model::GetPaymentRequest::PaymentHash {
2801 payment_hash: var_paymentHash,
2802 };
2803 }
2804 1 => {
2805 let mut var_swapId = <String>::sse_decode(deserializer);
2806 return crate::model::GetPaymentRequest::SwapId {
2807 swap_id: var_swapId,
2808 };
2809 }
2810 _ => {
2811 unimplemented!("");
2812 }
2813 }
2814 }
2815}
2816
2817impl SseDecode for i32 {
2818 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2820 deserializer.cursor.read_i32::<NativeEndian>().unwrap()
2821 }
2822}
2823
2824impl SseDecode for i64 {
2825 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2827 deserializer.cursor.read_i64::<NativeEndian>().unwrap()
2828 }
2829}
2830
2831impl SseDecode for crate::bindings::InputType {
2832 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2834 let mut tag_ = <i32>::sse_decode(deserializer);
2835 match tag_ {
2836 0 => {
2837 let mut var_address =
2838 <crate::bindings::BitcoinAddressData>::sse_decode(deserializer);
2839 return crate::bindings::InputType::BitcoinAddress {
2840 address: var_address,
2841 };
2842 }
2843 1 => {
2844 let mut var_address =
2845 <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
2846 return crate::bindings::InputType::LiquidAddress {
2847 address: var_address,
2848 };
2849 }
2850 2 => {
2851 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
2852 return crate::bindings::InputType::Bolt11 {
2853 invoice: var_invoice,
2854 };
2855 }
2856 3 => {
2857 let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
2858 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2859 return crate::bindings::InputType::Bolt12Offer {
2860 offer: var_offer,
2861 bip353_address: var_bip353Address,
2862 };
2863 }
2864 4 => {
2865 let mut var_nodeId = <String>::sse_decode(deserializer);
2866 return crate::bindings::InputType::NodeId {
2867 node_id: var_nodeId,
2868 };
2869 }
2870 5 => {
2871 let mut var_url = <String>::sse_decode(deserializer);
2872 return crate::bindings::InputType::Url { url: var_url };
2873 }
2874 6 => {
2875 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
2876 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2877 return crate::bindings::InputType::LnUrlPay {
2878 data: var_data,
2879 bip353_address: var_bip353Address,
2880 };
2881 }
2882 7 => {
2883 let mut var_data =
2884 <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
2885 return crate::bindings::InputType::LnUrlWithdraw { data: var_data };
2886 }
2887 8 => {
2888 let mut var_data =
2889 <crate::bindings::LnUrlAuthRequestData>::sse_decode(deserializer);
2890 return crate::bindings::InputType::LnUrlAuth { data: var_data };
2891 }
2892 9 => {
2893 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
2894 return crate::bindings::InputType::LnUrlError { data: var_data };
2895 }
2896 _ => {
2897 unimplemented!("");
2898 }
2899 }
2900 }
2901}
2902
2903impl SseDecode for crate::model::LightningPaymentLimitsResponse {
2904 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2906 let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
2907 let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
2908 return crate::model::LightningPaymentLimitsResponse {
2909 send: var_send,
2910 receive: var_receive,
2911 };
2912 }
2913}
2914
2915impl SseDecode for crate::model::Limits {
2916 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2918 let mut var_minSat = <u64>::sse_decode(deserializer);
2919 let mut var_maxSat = <u64>::sse_decode(deserializer);
2920 let mut var_maxZeroConfSat = <u64>::sse_decode(deserializer);
2921 return crate::model::Limits {
2922 min_sat: var_minSat,
2923 max_sat: var_maxSat,
2924 max_zero_conf_sat: var_maxZeroConfSat,
2925 };
2926 }
2927}
2928
2929impl SseDecode for crate::bindings::LiquidAddressData {
2930 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2932 let mut var_address = <String>::sse_decode(deserializer);
2933 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2934 let mut var_assetId = <Option<String>>::sse_decode(deserializer);
2935 let mut var_amount = <Option<f64>>::sse_decode(deserializer);
2936 let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2937 let mut var_label = <Option<String>>::sse_decode(deserializer);
2938 let mut var_message = <Option<String>>::sse_decode(deserializer);
2939 return crate::bindings::LiquidAddressData {
2940 address: var_address,
2941 network: var_network,
2942 asset_id: var_assetId,
2943 amount: var_amount,
2944 amount_sat: var_amountSat,
2945 label: var_label,
2946 message: var_message,
2947 };
2948 }
2949}
2950
2951impl SseDecode for crate::model::LiquidNetwork {
2952 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2954 let mut inner = <i32>::sse_decode(deserializer);
2955 return match inner {
2956 0 => crate::model::LiquidNetwork::Mainnet,
2957 1 => crate::model::LiquidNetwork::Testnet,
2958 2 => crate::model::LiquidNetwork::Regtest,
2959 _ => unreachable!("Invalid variant for LiquidNetwork: {}", inner),
2960 };
2961 }
2962}
2963
2964impl SseDecode for Vec<String> {
2965 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2967 let mut len_ = <i32>::sse_decode(deserializer);
2968 let mut ans_ = vec![];
2969 for idx_ in 0..len_ {
2970 ans_.push(<String>::sse_decode(deserializer));
2971 }
2972 return ans_;
2973 }
2974}
2975
2976impl SseDecode for Vec<crate::model::AssetBalance> {
2977 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2979 let mut len_ = <i32>::sse_decode(deserializer);
2980 let mut ans_ = vec![];
2981 for idx_ in 0..len_ {
2982 ans_.push(<crate::model::AssetBalance>::sse_decode(deserializer));
2983 }
2984 return ans_;
2985 }
2986}
2987
2988impl SseDecode for Vec<crate::model::AssetMetadata> {
2989 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2991 let mut len_ = <i32>::sse_decode(deserializer);
2992 let mut ans_ = vec![];
2993 for idx_ in 0..len_ {
2994 ans_.push(<crate::model::AssetMetadata>::sse_decode(deserializer));
2995 }
2996 return ans_;
2997 }
2998}
2999
3000impl SseDecode for Vec<crate::bindings::ExternalInputParser> {
3001 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3003 let mut len_ = <i32>::sse_decode(deserializer);
3004 let mut ans_ = vec![];
3005 for idx_ in 0..len_ {
3006 ans_.push(<crate::bindings::ExternalInputParser>::sse_decode(
3007 deserializer,
3008 ));
3009 }
3010 return ans_;
3011 }
3012}
3013
3014impl SseDecode for Vec<crate::bindings::FiatCurrency> {
3015 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3017 let mut len_ = <i32>::sse_decode(deserializer);
3018 let mut ans_ = vec![];
3019 for idx_ in 0..len_ {
3020 ans_.push(<crate::bindings::FiatCurrency>::sse_decode(deserializer));
3021 }
3022 return ans_;
3023 }
3024}
3025
3026impl SseDecode for Vec<crate::bindings::LnOfferBlindedPath> {
3027 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3029 let mut len_ = <i32>::sse_decode(deserializer);
3030 let mut ans_ = vec![];
3031 for idx_ in 0..len_ {
3032 ans_.push(<crate::bindings::LnOfferBlindedPath>::sse_decode(
3033 deserializer,
3034 ));
3035 }
3036 return ans_;
3037 }
3038}
3039
3040impl SseDecode for Vec<crate::bindings::LocaleOverrides> {
3041 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3043 let mut len_ = <i32>::sse_decode(deserializer);
3044 let mut ans_ = vec![];
3045 for idx_ in 0..len_ {
3046 ans_.push(<crate::bindings::LocaleOverrides>::sse_decode(deserializer));
3047 }
3048 return ans_;
3049 }
3050}
3051
3052impl SseDecode for Vec<crate::bindings::LocalizedName> {
3053 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3055 let mut len_ = <i32>::sse_decode(deserializer);
3056 let mut ans_ = vec![];
3057 for idx_ in 0..len_ {
3058 ans_.push(<crate::bindings::LocalizedName>::sse_decode(deserializer));
3059 }
3060 return ans_;
3061 }
3062}
3063
3064impl SseDecode for Vec<crate::model::Payment> {
3065 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3067 let mut len_ = <i32>::sse_decode(deserializer);
3068 let mut ans_ = vec![];
3069 for idx_ in 0..len_ {
3070 ans_.push(<crate::model::Payment>::sse_decode(deserializer));
3071 }
3072 return ans_;
3073 }
3074}
3075
3076impl SseDecode for crate::model::ListPaymentDetails {
3077 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3079 let mut tag_ = <i32>::sse_decode(deserializer);
3080 match tag_ {
3081 0 => {
3082 let mut var_assetId = <Option<String>>::sse_decode(deserializer);
3083 let mut var_destination = <Option<String>>::sse_decode(deserializer);
3084 return crate::model::ListPaymentDetails::Liquid {
3085 asset_id: var_assetId,
3086 destination: var_destination,
3087 };
3088 }
3089 1 => {
3090 let mut var_address = <Option<String>>::sse_decode(deserializer);
3091 return crate::model::ListPaymentDetails::Bitcoin {
3092 address: var_address,
3093 };
3094 }
3095 _ => {
3096 unimplemented!("");
3097 }
3098 }
3099 }
3100}
3101
3102impl SseDecode for Vec<crate::model::PaymentState> {
3103 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3105 let mut len_ = <i32>::sse_decode(deserializer);
3106 let mut ans_ = vec![];
3107 for idx_ in 0..len_ {
3108 ans_.push(<crate::model::PaymentState>::sse_decode(deserializer));
3109 }
3110 return ans_;
3111 }
3112}
3113
3114impl SseDecode for Vec<crate::model::PaymentType> {
3115 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3117 let mut len_ = <i32>::sse_decode(deserializer);
3118 let mut ans_ = vec![];
3119 for idx_ in 0..len_ {
3120 ans_.push(<crate::model::PaymentType>::sse_decode(deserializer));
3121 }
3122 return ans_;
3123 }
3124}
3125
3126impl SseDecode for crate::model::ListPaymentsRequest {
3127 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3129 let mut var_filters = <Option<Vec<crate::model::PaymentType>>>::sse_decode(deserializer);
3130 let mut var_states = <Option<Vec<crate::model::PaymentState>>>::sse_decode(deserializer);
3131 let mut var_fromTimestamp = <Option<i64>>::sse_decode(deserializer);
3132 let mut var_toTimestamp = <Option<i64>>::sse_decode(deserializer);
3133 let mut var_offset = <Option<u32>>::sse_decode(deserializer);
3134 let mut var_limit = <Option<u32>>::sse_decode(deserializer);
3135 let mut var_details = <Option<crate::model::ListPaymentDetails>>::sse_decode(deserializer);
3136 let mut var_sortAscending = <Option<bool>>::sse_decode(deserializer);
3137 return crate::model::ListPaymentsRequest {
3138 filters: var_filters,
3139 states: var_states,
3140 from_timestamp: var_fromTimestamp,
3141 to_timestamp: var_toTimestamp,
3142 offset: var_offset,
3143 limit: var_limit,
3144 details: var_details,
3145 sort_ascending: var_sortAscending,
3146 };
3147 }
3148}
3149
3150impl SseDecode for Vec<u8> {
3151 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3153 let mut len_ = <i32>::sse_decode(deserializer);
3154 let mut ans_ = vec![];
3155 for idx_ in 0..len_ {
3156 ans_.push(<u8>::sse_decode(deserializer));
3157 }
3158 return ans_;
3159 }
3160}
3161
3162impl SseDecode for Vec<crate::bindings::Rate> {
3163 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3165 let mut len_ = <i32>::sse_decode(deserializer);
3166 let mut ans_ = vec![];
3167 for idx_ in 0..len_ {
3168 ans_.push(<crate::bindings::Rate>::sse_decode(deserializer));
3169 }
3170 return ans_;
3171 }
3172}
3173
3174impl SseDecode for Vec<crate::model::RefundableSwap> {
3175 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3177 let mut len_ = <i32>::sse_decode(deserializer);
3178 let mut ans_ = vec![];
3179 for idx_ in 0..len_ {
3180 ans_.push(<crate::model::RefundableSwap>::sse_decode(deserializer));
3181 }
3182 return ans_;
3183 }
3184}
3185
3186impl SseDecode for Vec<crate::bindings::RouteHint> {
3187 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3189 let mut len_ = <i32>::sse_decode(deserializer);
3190 let mut ans_ = vec![];
3191 for idx_ in 0..len_ {
3192 ans_.push(<crate::bindings::RouteHint>::sse_decode(deserializer));
3193 }
3194 return ans_;
3195 }
3196}
3197
3198impl SseDecode for Vec<crate::bindings::RouteHintHop> {
3199 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3201 let mut len_ = <i32>::sse_decode(deserializer);
3202 let mut ans_ = vec![];
3203 for idx_ in 0..len_ {
3204 ans_.push(<crate::bindings::RouteHintHop>::sse_decode(deserializer));
3205 }
3206 return ans_;
3207 }
3208}
3209
3210impl SseDecode for crate::bindings::LNInvoice {
3211 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3213 let mut var_bolt11 = <String>::sse_decode(deserializer);
3214 let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
3215 let mut var_payeePubkey = <String>::sse_decode(deserializer);
3216 let mut var_paymentHash = <String>::sse_decode(deserializer);
3217 let mut var_description = <Option<String>>::sse_decode(deserializer);
3218 let mut var_descriptionHash = <Option<String>>::sse_decode(deserializer);
3219 let mut var_amountMsat = <Option<u64>>::sse_decode(deserializer);
3220 let mut var_timestamp = <u64>::sse_decode(deserializer);
3221 let mut var_expiry = <u64>::sse_decode(deserializer);
3222 let mut var_routingHints = <Vec<crate::bindings::RouteHint>>::sse_decode(deserializer);
3223 let mut var_paymentSecret = <Vec<u8>>::sse_decode(deserializer);
3224 let mut var_minFinalCltvExpiryDelta = <u64>::sse_decode(deserializer);
3225 return crate::bindings::LNInvoice {
3226 bolt11: var_bolt11,
3227 network: var_network,
3228 payee_pubkey: var_payeePubkey,
3229 payment_hash: var_paymentHash,
3230 description: var_description,
3231 description_hash: var_descriptionHash,
3232 amount_msat: var_amountMsat,
3233 timestamp: var_timestamp,
3234 expiry: var_expiry,
3235 routing_hints: var_routingHints,
3236 payment_secret: var_paymentSecret,
3237 min_final_cltv_expiry_delta: var_minFinalCltvExpiryDelta,
3238 };
3239 }
3240}
3241
3242impl SseDecode for crate::bindings::LNOffer {
3243 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3245 let mut var_offer = <String>::sse_decode(deserializer);
3246 let mut var_chains = <Vec<String>>::sse_decode(deserializer);
3247 let mut var_minAmount = <Option<crate::bindings::Amount>>::sse_decode(deserializer);
3248 let mut var_description = <Option<String>>::sse_decode(deserializer);
3249 let mut var_absoluteExpiry = <Option<u64>>::sse_decode(deserializer);
3250 let mut var_issuer = <Option<String>>::sse_decode(deserializer);
3251 let mut var_signingPubkey = <Option<String>>::sse_decode(deserializer);
3252 let mut var_paths = <Vec<crate::bindings::LnOfferBlindedPath>>::sse_decode(deserializer);
3253 return crate::bindings::LNOffer {
3254 offer: var_offer,
3255 chains: var_chains,
3256 min_amount: var_minAmount,
3257 description: var_description,
3258 absolute_expiry: var_absoluteExpiry,
3259 issuer: var_issuer,
3260 signing_pubkey: var_signingPubkey,
3261 paths: var_paths,
3262 };
3263 }
3264}
3265
3266impl SseDecode for crate::bindings::LnOfferBlindedPath {
3267 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3269 let mut var_blindedHops = <Vec<String>>::sse_decode(deserializer);
3270 return crate::bindings::LnOfferBlindedPath {
3271 blinded_hops: var_blindedHops,
3272 };
3273 }
3274}
3275
3276impl SseDecode for crate::bindings::duplicates::LnUrlAuthError {
3277 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3279 let mut tag_ = <i32>::sse_decode(deserializer);
3280 match tag_ {
3281 0 => {
3282 let mut var_err = <String>::sse_decode(deserializer);
3283 return crate::bindings::duplicates::LnUrlAuthError::Generic { err: var_err };
3284 }
3285 1 => {
3286 let mut var_err = <String>::sse_decode(deserializer);
3287 return crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err: var_err };
3288 }
3289 2 => {
3290 let mut var_err = <String>::sse_decode(deserializer);
3291 return crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
3292 err: var_err,
3293 };
3294 }
3295 _ => {
3296 unimplemented!("");
3297 }
3298 }
3299 }
3300}
3301
3302impl SseDecode for crate::bindings::LnUrlAuthRequestData {
3303 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3305 let mut var_k1 = <String>::sse_decode(deserializer);
3306 let mut var_action = <Option<String>>::sse_decode(deserializer);
3307 let mut var_domain = <String>::sse_decode(deserializer);
3308 let mut var_url = <String>::sse_decode(deserializer);
3309 return crate::bindings::LnUrlAuthRequestData {
3310 k1: var_k1,
3311 action: var_action,
3312 domain: var_domain,
3313 url: var_url,
3314 };
3315 }
3316}
3317
3318impl SseDecode for crate::bindings::duplicates::LnUrlCallbackStatus {
3319 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3321 let mut tag_ = <i32>::sse_decode(deserializer);
3322 match tag_ {
3323 0 => {
3324 return crate::bindings::duplicates::LnUrlCallbackStatus::Ok;
3325 }
3326 1 => {
3327 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3328 return crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
3329 data: var_data,
3330 };
3331 }
3332 _ => {
3333 unimplemented!("");
3334 }
3335 }
3336 }
3337}
3338
3339impl SseDecode for crate::bindings::LnUrlErrorData {
3340 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3342 let mut var_reason = <String>::sse_decode(deserializer);
3343 return crate::bindings::LnUrlErrorData { reason: var_reason };
3344 }
3345}
3346
3347impl SseDecode for crate::model::LnUrlInfo {
3348 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3350 let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3351 let mut var_lnurlPayComment = <Option<String>>::sse_decode(deserializer);
3352 let mut var_lnurlPayDomain = <Option<String>>::sse_decode(deserializer);
3353 let mut var_lnurlPayMetadata = <Option<String>>::sse_decode(deserializer);
3354 let mut var_lnurlPaySuccessAction =
3355 <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3356 let mut var_lnurlPayUnprocessedSuccessAction =
3357 <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
3358 let mut var_lnurlWithdrawEndpoint = <Option<String>>::sse_decode(deserializer);
3359 return crate::model::LnUrlInfo {
3360 ln_address: var_lnAddress,
3361 lnurl_pay_comment: var_lnurlPayComment,
3362 lnurl_pay_domain: var_lnurlPayDomain,
3363 lnurl_pay_metadata: var_lnurlPayMetadata,
3364 lnurl_pay_success_action: var_lnurlPaySuccessAction,
3365 lnurl_pay_unprocessed_success_action: var_lnurlPayUnprocessedSuccessAction,
3366 lnurl_withdraw_endpoint: var_lnurlWithdrawEndpoint,
3367 };
3368 }
3369}
3370
3371impl SseDecode for crate::bindings::duplicates::LnUrlPayError {
3372 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3374 let mut tag_ = <i32>::sse_decode(deserializer);
3375 match tag_ {
3376 0 => {
3377 return crate::bindings::duplicates::LnUrlPayError::AlreadyPaid;
3378 }
3379 1 => {
3380 let mut var_err = <String>::sse_decode(deserializer);
3381 return crate::bindings::duplicates::LnUrlPayError::Generic { err: var_err };
3382 }
3383 2 => {
3384 let mut var_err = <String>::sse_decode(deserializer);
3385 return crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
3386 err: var_err,
3387 };
3388 }
3389 3 => {
3390 let mut var_err = <String>::sse_decode(deserializer);
3391 return crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err: var_err };
3392 }
3393 4 => {
3394 let mut var_err = <String>::sse_decode(deserializer);
3395 return crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err: var_err };
3396 }
3397 5 => {
3398 let mut var_err = <String>::sse_decode(deserializer);
3399 return crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err: var_err };
3400 }
3401 6 => {
3402 let mut var_err = <String>::sse_decode(deserializer);
3403 return crate::bindings::duplicates::LnUrlPayError::InvalidUri { err: var_err };
3404 }
3405 7 => {
3406 let mut var_err = <String>::sse_decode(deserializer);
3407 return crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err: var_err };
3408 }
3409 8 => {
3410 let mut var_err = <String>::sse_decode(deserializer);
3411 return crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err: var_err };
3412 }
3413 9 => {
3414 let mut var_err = <String>::sse_decode(deserializer);
3415 return crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err: var_err };
3416 }
3417 10 => {
3418 let mut var_err = <String>::sse_decode(deserializer);
3419 return crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err: var_err };
3420 }
3421 11 => {
3422 let mut var_err = <String>::sse_decode(deserializer);
3423 return crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
3424 err: var_err,
3425 };
3426 }
3427 12 => {
3428 let mut var_err = <String>::sse_decode(deserializer);
3429 return crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
3430 err: var_err,
3431 };
3432 }
3433 _ => {
3434 unimplemented!("");
3435 }
3436 }
3437 }
3438}
3439
3440impl SseDecode for crate::bindings::LnUrlPayErrorData {
3441 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3443 let mut var_paymentHash = <String>::sse_decode(deserializer);
3444 let mut var_reason = <String>::sse_decode(deserializer);
3445 return crate::bindings::LnUrlPayErrorData {
3446 payment_hash: var_paymentHash,
3447 reason: var_reason,
3448 };
3449 }
3450}
3451
3452impl SseDecode for crate::model::LnUrlPayRequest {
3453 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3455 let mut var_prepareResponse =
3456 <crate::model::PrepareLnUrlPayResponse>::sse_decode(deserializer);
3457 return crate::model::LnUrlPayRequest {
3458 prepare_response: var_prepareResponse,
3459 };
3460 }
3461}
3462
3463impl SseDecode for crate::bindings::LnUrlPayRequestData {
3464 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3466 let mut var_callback = <String>::sse_decode(deserializer);
3467 let mut var_minSendable = <u64>::sse_decode(deserializer);
3468 let mut var_maxSendable = <u64>::sse_decode(deserializer);
3469 let mut var_metadataStr = <String>::sse_decode(deserializer);
3470 let mut var_commentAllowed = <u16>::sse_decode(deserializer);
3471 let mut var_domain = <String>::sse_decode(deserializer);
3472 let mut var_allowsNostr = <bool>::sse_decode(deserializer);
3473 let mut var_nostrPubkey = <Option<String>>::sse_decode(deserializer);
3474 let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3475 return crate::bindings::LnUrlPayRequestData {
3476 callback: var_callback,
3477 min_sendable: var_minSendable,
3478 max_sendable: var_maxSendable,
3479 metadata_str: var_metadataStr,
3480 comment_allowed: var_commentAllowed,
3481 domain: var_domain,
3482 allows_nostr: var_allowsNostr,
3483 nostr_pubkey: var_nostrPubkey,
3484 ln_address: var_lnAddress,
3485 };
3486 }
3487}
3488
3489impl SseDecode for crate::model::LnUrlPayResult {
3490 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3492 let mut tag_ = <i32>::sse_decode(deserializer);
3493 match tag_ {
3494 0 => {
3495 let mut var_data = <crate::model::LnUrlPaySuccessData>::sse_decode(deserializer);
3496 return crate::model::LnUrlPayResult::EndpointSuccess { data: var_data };
3497 }
3498 1 => {
3499 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3500 return crate::model::LnUrlPayResult::EndpointError { data: var_data };
3501 }
3502 2 => {
3503 let mut var_data = <crate::bindings::LnUrlPayErrorData>::sse_decode(deserializer);
3504 return crate::model::LnUrlPayResult::PayError { data: var_data };
3505 }
3506 _ => {
3507 unimplemented!("");
3508 }
3509 }
3510 }
3511}
3512
3513impl SseDecode for crate::model::LnUrlPaySuccessData {
3514 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3516 let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
3517 let mut var_successAction =
3518 <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3519 return crate::model::LnUrlPaySuccessData {
3520 payment: var_payment,
3521 success_action: var_successAction,
3522 };
3523 }
3524}
3525
3526impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawError {
3527 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3529 let mut tag_ = <i32>::sse_decode(deserializer);
3530 match tag_ {
3531 0 => {
3532 let mut var_err = <String>::sse_decode(deserializer);
3533 return crate::bindings::duplicates::LnUrlWithdrawError::Generic { err: var_err };
3534 }
3535 1 => {
3536 let mut var_err = <String>::sse_decode(deserializer);
3537 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
3538 err: var_err,
3539 };
3540 }
3541 2 => {
3542 let mut var_err = <String>::sse_decode(deserializer);
3543 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
3544 err: var_err,
3545 };
3546 }
3547 3 => {
3548 let mut var_err = <String>::sse_decode(deserializer);
3549 return crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
3550 err: var_err,
3551 };
3552 }
3553 4 => {
3554 let mut var_err = <String>::sse_decode(deserializer);
3555 return crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
3556 err: var_err,
3557 };
3558 }
3559 5 => {
3560 let mut var_err = <String>::sse_decode(deserializer);
3561 return crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
3562 err: var_err,
3563 };
3564 }
3565 _ => {
3566 unimplemented!("");
3567 }
3568 }
3569 }
3570}
3571
3572impl SseDecode for crate::bindings::LnUrlWithdrawRequest {
3573 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3575 let mut var_data = <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
3576 let mut var_amountMsat = <u64>::sse_decode(deserializer);
3577 let mut var_description = <Option<String>>::sse_decode(deserializer);
3578 return crate::bindings::LnUrlWithdrawRequest {
3579 data: var_data,
3580 amount_msat: var_amountMsat,
3581 description: var_description,
3582 };
3583 }
3584}
3585
3586impl SseDecode for crate::bindings::LnUrlWithdrawRequestData {
3587 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3589 let mut var_callback = <String>::sse_decode(deserializer);
3590 let mut var_k1 = <String>::sse_decode(deserializer);
3591 let mut var_defaultDescription = <String>::sse_decode(deserializer);
3592 let mut var_minWithdrawable = <u64>::sse_decode(deserializer);
3593 let mut var_maxWithdrawable = <u64>::sse_decode(deserializer);
3594 return crate::bindings::LnUrlWithdrawRequestData {
3595 callback: var_callback,
3596 k1: var_k1,
3597 default_description: var_defaultDescription,
3598 min_withdrawable: var_minWithdrawable,
3599 max_withdrawable: var_maxWithdrawable,
3600 };
3601 }
3602}
3603
3604impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawResult {
3605 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3607 let mut tag_ = <i32>::sse_decode(deserializer);
3608 match tag_ {
3609 0 => {
3610 let mut var_data =
3611 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3612 deserializer,
3613 );
3614 return crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data: var_data };
3615 }
3616 1 => {
3617 let mut var_data =
3618 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3619 deserializer,
3620 );
3621 return crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
3622 data: var_data,
3623 };
3624 }
3625 2 => {
3626 let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3627 return crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
3628 data: var_data,
3629 };
3630 }
3631 _ => {
3632 unimplemented!("");
3633 }
3634 }
3635 }
3636}
3637
3638impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3639 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3641 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
3642 return crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3643 invoice: var_invoice,
3644 };
3645 }
3646}
3647
3648impl SseDecode for crate::bindings::LocaleOverrides {
3649 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3651 let mut var_locale = <String>::sse_decode(deserializer);
3652 let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
3653 let mut var_symbol = <crate::bindings::Symbol>::sse_decode(deserializer);
3654 return crate::bindings::LocaleOverrides {
3655 locale: var_locale,
3656 spacing: var_spacing,
3657 symbol: var_symbol,
3658 };
3659 }
3660}
3661
3662impl SseDecode for crate::bindings::LocalizedName {
3663 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3665 let mut var_locale = <String>::sse_decode(deserializer);
3666 let mut var_name = <String>::sse_decode(deserializer);
3667 return crate::bindings::LocalizedName {
3668 locale: var_locale,
3669 name: var_name,
3670 };
3671 }
3672}
3673
3674impl SseDecode for crate::model::LogEntry {
3675 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3677 let mut var_line = <String>::sse_decode(deserializer);
3678 let mut var_level = <String>::sse_decode(deserializer);
3679 return crate::model::LogEntry {
3680 line: var_line,
3681 level: var_level,
3682 };
3683 }
3684}
3685
3686impl SseDecode for crate::bindings::MessageSuccessActionData {
3687 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3689 let mut var_message = <String>::sse_decode(deserializer);
3690 return crate::bindings::MessageSuccessActionData {
3691 message: var_message,
3692 };
3693 }
3694}
3695
3696impl SseDecode for crate::bindings::Network {
3697 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3699 let mut inner = <i32>::sse_decode(deserializer);
3700 return match inner {
3701 0 => crate::bindings::Network::Bitcoin,
3702 1 => crate::bindings::Network::Testnet,
3703 2 => crate::bindings::Network::Signet,
3704 3 => crate::bindings::Network::Regtest,
3705 _ => unreachable!("Invalid variant for Network: {}", inner),
3706 };
3707 }
3708}
3709
3710impl SseDecode for crate::model::OnchainPaymentLimitsResponse {
3711 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3713 let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
3714 let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
3715 return crate::model::OnchainPaymentLimitsResponse {
3716 send: var_send,
3717 receive: var_receive,
3718 };
3719 }
3720}
3721
3722impl SseDecode for Option<String> {
3723 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3725 if (<bool>::sse_decode(deserializer)) {
3726 return Some(<String>::sse_decode(deserializer));
3727 } else {
3728 return None;
3729 }
3730 }
3731}
3732
3733impl SseDecode for Option<crate::bindings::Amount> {
3734 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3736 if (<bool>::sse_decode(deserializer)) {
3737 return Some(<crate::bindings::Amount>::sse_decode(deserializer));
3738 } else {
3739 return None;
3740 }
3741 }
3742}
3743
3744impl SseDecode for Option<crate::model::AssetInfo> {
3745 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3747 if (<bool>::sse_decode(deserializer)) {
3748 return Some(<crate::model::AssetInfo>::sse_decode(deserializer));
3749 } else {
3750 return None;
3751 }
3752 }
3753}
3754
3755impl SseDecode for Option<bool> {
3756 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3758 if (<bool>::sse_decode(deserializer)) {
3759 return Some(<bool>::sse_decode(deserializer));
3760 } else {
3761 return None;
3762 }
3763 }
3764}
3765
3766impl SseDecode for Option<f64> {
3767 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3769 if (<bool>::sse_decode(deserializer)) {
3770 return Some(<f64>::sse_decode(deserializer));
3771 } else {
3772 return None;
3773 }
3774 }
3775}
3776
3777impl SseDecode for Option<i64> {
3778 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3780 if (<bool>::sse_decode(deserializer)) {
3781 return Some(<i64>::sse_decode(deserializer));
3782 } else {
3783 return None;
3784 }
3785 }
3786}
3787
3788impl SseDecode for Option<crate::model::ListPaymentDetails> {
3789 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3791 if (<bool>::sse_decode(deserializer)) {
3792 return Some(<crate::model::ListPaymentDetails>::sse_decode(deserializer));
3793 } else {
3794 return None;
3795 }
3796 }
3797}
3798
3799impl SseDecode for Option<crate::model::LnUrlInfo> {
3800 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3802 if (<bool>::sse_decode(deserializer)) {
3803 return Some(<crate::model::LnUrlInfo>::sse_decode(deserializer));
3804 } else {
3805 return None;
3806 }
3807 }
3808}
3809
3810impl SseDecode for Option<crate::model::PayAmount> {
3811 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3813 if (<bool>::sse_decode(deserializer)) {
3814 return Some(<crate::model::PayAmount>::sse_decode(deserializer));
3815 } else {
3816 return None;
3817 }
3818 }
3819}
3820
3821impl SseDecode for Option<crate::model::Payment> {
3822 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3824 if (<bool>::sse_decode(deserializer)) {
3825 return Some(<crate::model::Payment>::sse_decode(deserializer));
3826 } else {
3827 return None;
3828 }
3829 }
3830}
3831
3832impl SseDecode for Option<crate::model::ReceiveAmount> {
3833 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3835 if (<bool>::sse_decode(deserializer)) {
3836 return Some(<crate::model::ReceiveAmount>::sse_decode(deserializer));
3837 } else {
3838 return None;
3839 }
3840 }
3841}
3842
3843impl SseDecode for Option<crate::bindings::SuccessAction> {
3844 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3846 if (<bool>::sse_decode(deserializer)) {
3847 return Some(<crate::bindings::SuccessAction>::sse_decode(deserializer));
3848 } else {
3849 return None;
3850 }
3851 }
3852}
3853
3854impl SseDecode for Option<crate::bindings::SuccessActionProcessed> {
3855 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3857 if (<bool>::sse_decode(deserializer)) {
3858 return Some(<crate::bindings::SuccessActionProcessed>::sse_decode(
3859 deserializer,
3860 ));
3861 } else {
3862 return None;
3863 }
3864 }
3865}
3866
3867impl SseDecode for Option<crate::bindings::Symbol> {
3868 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3870 if (<bool>::sse_decode(deserializer)) {
3871 return Some(<crate::bindings::Symbol>::sse_decode(deserializer));
3872 } else {
3873 return None;
3874 }
3875 }
3876}
3877
3878impl SseDecode for Option<u32> {
3879 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3881 if (<bool>::sse_decode(deserializer)) {
3882 return Some(<u32>::sse_decode(deserializer));
3883 } else {
3884 return None;
3885 }
3886 }
3887}
3888
3889impl SseDecode for Option<u64> {
3890 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3892 if (<bool>::sse_decode(deserializer)) {
3893 return Some(<u64>::sse_decode(deserializer));
3894 } else {
3895 return None;
3896 }
3897 }
3898}
3899
3900impl SseDecode for Option<Vec<crate::model::AssetMetadata>> {
3901 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3903 if (<bool>::sse_decode(deserializer)) {
3904 return Some(<Vec<crate::model::AssetMetadata>>::sse_decode(deserializer));
3905 } else {
3906 return None;
3907 }
3908 }
3909}
3910
3911impl SseDecode for Option<Vec<crate::bindings::ExternalInputParser>> {
3912 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3914 if (<bool>::sse_decode(deserializer)) {
3915 return Some(<Vec<crate::bindings::ExternalInputParser>>::sse_decode(
3916 deserializer,
3917 ));
3918 } else {
3919 return None;
3920 }
3921 }
3922}
3923
3924impl SseDecode for Option<Vec<crate::model::PaymentState>> {
3925 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3927 if (<bool>::sse_decode(deserializer)) {
3928 return Some(<Vec<crate::model::PaymentState>>::sse_decode(deserializer));
3929 } else {
3930 return None;
3931 }
3932 }
3933}
3934
3935impl SseDecode for Option<Vec<crate::model::PaymentType>> {
3936 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3938 if (<bool>::sse_decode(deserializer)) {
3939 return Some(<Vec<crate::model::PaymentType>>::sse_decode(deserializer));
3940 } else {
3941 return None;
3942 }
3943 }
3944}
3945
3946impl SseDecode for Option<Vec<u8>> {
3947 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3949 if (<bool>::sse_decode(deserializer)) {
3950 return Some(<Vec<u8>>::sse_decode(deserializer));
3951 } else {
3952 return None;
3953 }
3954 }
3955}
3956
3957impl SseDecode for crate::model::PayAmount {
3958 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3960 let mut tag_ = <i32>::sse_decode(deserializer);
3961 match tag_ {
3962 0 => {
3963 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
3964 return crate::model::PayAmount::Bitcoin {
3965 receiver_amount_sat: var_receiverAmountSat,
3966 };
3967 }
3968 1 => {
3969 let mut var_assetId = <String>::sse_decode(deserializer);
3970 let mut var_receiverAmount = <f64>::sse_decode(deserializer);
3971 let mut var_estimateAssetFees = <Option<bool>>::sse_decode(deserializer);
3972 return crate::model::PayAmount::Asset {
3973 asset_id: var_assetId,
3974 receiver_amount: var_receiverAmount,
3975 estimate_asset_fees: var_estimateAssetFees,
3976 };
3977 }
3978 2 => {
3979 return crate::model::PayAmount::Drain;
3980 }
3981 _ => {
3982 unimplemented!("");
3983 }
3984 }
3985 }
3986}
3987
3988impl SseDecode for crate::model::PayOnchainRequest {
3989 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3991 let mut var_address = <String>::sse_decode(deserializer);
3992 let mut var_prepareResponse =
3993 <crate::model::PreparePayOnchainResponse>::sse_decode(deserializer);
3994 return crate::model::PayOnchainRequest {
3995 address: var_address,
3996 prepare_response: var_prepareResponse,
3997 };
3998 }
3999}
4000
4001impl SseDecode for crate::model::Payment {
4002 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4004 let mut var_destination = <Option<String>>::sse_decode(deserializer);
4005 let mut var_txId = <Option<String>>::sse_decode(deserializer);
4006 let mut var_unblindingData = <Option<String>>::sse_decode(deserializer);
4007 let mut var_timestamp = <u32>::sse_decode(deserializer);
4008 let mut var_amountSat = <u64>::sse_decode(deserializer);
4009 let mut var_feesSat = <u64>::sse_decode(deserializer);
4010 let mut var_swapperFeesSat = <Option<u64>>::sse_decode(deserializer);
4011 let mut var_paymentType = <crate::model::PaymentType>::sse_decode(deserializer);
4012 let mut var_status = <crate::model::PaymentState>::sse_decode(deserializer);
4013 let mut var_details = <crate::model::PaymentDetails>::sse_decode(deserializer);
4014 return crate::model::Payment {
4015 destination: var_destination,
4016 tx_id: var_txId,
4017 unblinding_data: var_unblindingData,
4018 timestamp: var_timestamp,
4019 amount_sat: var_amountSat,
4020 fees_sat: var_feesSat,
4021 swapper_fees_sat: var_swapperFeesSat,
4022 payment_type: var_paymentType,
4023 status: var_status,
4024 details: var_details,
4025 };
4026 }
4027}
4028
4029impl SseDecode for crate::model::PaymentDetails {
4030 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4032 let mut tag_ = <i32>::sse_decode(deserializer);
4033 match tag_ {
4034 0 => {
4035 let mut var_swapId = <String>::sse_decode(deserializer);
4036 let mut var_description = <String>::sse_decode(deserializer);
4037 let mut var_liquidExpirationBlockheight = <u32>::sse_decode(deserializer);
4038 let mut var_preimage = <Option<String>>::sse_decode(deserializer);
4039 let mut var_invoice = <Option<String>>::sse_decode(deserializer);
4040 let mut var_bolt12Offer = <Option<String>>::sse_decode(deserializer);
4041 let mut var_paymentHash = <Option<String>>::sse_decode(deserializer);
4042 let mut var_destinationPubkey = <Option<String>>::sse_decode(deserializer);
4043 let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4044 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4045 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4046 let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4047 let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4048 let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4049 return crate::model::PaymentDetails::Lightning {
4050 swap_id: var_swapId,
4051 description: var_description,
4052 liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4053 preimage: var_preimage,
4054 invoice: var_invoice,
4055 bolt12_offer: var_bolt12Offer,
4056 payment_hash: var_paymentHash,
4057 destination_pubkey: var_destinationPubkey,
4058 lnurl_info: var_lnurlInfo,
4059 bip353_address: var_bip353Address,
4060 payer_note: var_payerNote,
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 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4074 return crate::model::PaymentDetails::Liquid {
4075 destination: var_destination,
4076 description: var_description,
4077 asset_id: var_assetId,
4078 asset_info: var_assetInfo,
4079 lnurl_info: var_lnurlInfo,
4080 bip353_address: var_bip353Address,
4081 payer_note: var_payerNote,
4082 };
4083 }
4084 2 => {
4085 let mut var_swapId = <String>::sse_decode(deserializer);
4086 let mut var_bitcoinAddress = <String>::sse_decode(deserializer);
4087 let mut var_description = <String>::sse_decode(deserializer);
4088 let mut var_autoAcceptedFees = <bool>::sse_decode(deserializer);
4089 let mut var_liquidExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4090 let mut var_bitcoinExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4091 let mut var_lockupTxId = <Option<String>>::sse_decode(deserializer);
4092 let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4093 let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4094 let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4095 return crate::model::PaymentDetails::Bitcoin {
4096 swap_id: var_swapId,
4097 bitcoin_address: var_bitcoinAddress,
4098 description: var_description,
4099 auto_accepted_fees: var_autoAcceptedFees,
4100 liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4101 bitcoin_expiration_blockheight: var_bitcoinExpirationBlockheight,
4102 lockup_tx_id: var_lockupTxId,
4103 claim_tx_id: var_claimTxId,
4104 refund_tx_id: var_refundTxId,
4105 refund_tx_amount_sat: var_refundTxAmountSat,
4106 };
4107 }
4108 _ => {
4109 unimplemented!("");
4110 }
4111 }
4112 }
4113}
4114
4115impl SseDecode for crate::error::PaymentError {
4116 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4118 let mut tag_ = <i32>::sse_decode(deserializer);
4119 match tag_ {
4120 0 => {
4121 return crate::error::PaymentError::AlreadyClaimed;
4122 }
4123 1 => {
4124 return crate::error::PaymentError::AlreadyPaid;
4125 }
4126 2 => {
4127 return crate::error::PaymentError::PaymentInProgress;
4128 }
4129 3 => {
4130 let mut var_min = <u64>::sse_decode(deserializer);
4131 let mut var_max = <u64>::sse_decode(deserializer);
4132 return crate::error::PaymentError::AmountOutOfRange {
4133 min: var_min,
4134 max: var_max,
4135 };
4136 }
4137 4 => {
4138 let mut var_err = <String>::sse_decode(deserializer);
4139 return crate::error::PaymentError::AmountMissing { err: var_err };
4140 }
4141 5 => {
4142 let mut var_err = <String>::sse_decode(deserializer);
4143 return crate::error::PaymentError::AssetError { err: var_err };
4144 }
4145 6 => {
4146 let mut var_err = <String>::sse_decode(deserializer);
4147 return crate::error::PaymentError::InvalidNetwork { err: var_err };
4148 }
4149 7 => {
4150 let mut var_err = <String>::sse_decode(deserializer);
4151 return crate::error::PaymentError::Generic { err: var_err };
4152 }
4153 8 => {
4154 return crate::error::PaymentError::InvalidOrExpiredFees;
4155 }
4156 9 => {
4157 return crate::error::PaymentError::InsufficientFunds;
4158 }
4159 10 => {
4160 let mut var_err = <String>::sse_decode(deserializer);
4161 return crate::error::PaymentError::InvalidDescription { err: var_err };
4162 }
4163 11 => {
4164 let mut var_err = <String>::sse_decode(deserializer);
4165 return crate::error::PaymentError::InvalidInvoice { err: var_err };
4166 }
4167 12 => {
4168 return crate::error::PaymentError::InvalidPreimage;
4169 }
4170 13 => {
4171 return crate::error::PaymentError::PairsNotFound;
4172 }
4173 14 => {
4174 return crate::error::PaymentError::PaymentTimeout;
4175 }
4176 15 => {
4177 return crate::error::PaymentError::PersistError;
4178 }
4179 16 => {
4180 let mut var_err = <String>::sse_decode(deserializer);
4181 return crate::error::PaymentError::ReceiveError { err: var_err };
4182 }
4183 17 => {
4184 let mut var_err = <String>::sse_decode(deserializer);
4185 let mut var_refundTxId = <String>::sse_decode(deserializer);
4186 return crate::error::PaymentError::Refunded {
4187 err: var_err,
4188 refund_tx_id: var_refundTxId,
4189 };
4190 }
4191 18 => {
4192 return crate::error::PaymentError::SelfTransferNotSupported;
4193 }
4194 19 => {
4195 let mut var_err = <String>::sse_decode(deserializer);
4196 return crate::error::PaymentError::SendError { err: var_err };
4197 }
4198 20 => {
4199 let mut var_err = <String>::sse_decode(deserializer);
4200 return crate::error::PaymentError::SignerError { err: var_err };
4201 }
4202 _ => {
4203 unimplemented!("");
4204 }
4205 }
4206 }
4207}
4208
4209impl SseDecode for crate::model::PaymentMethod {
4210 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4212 let mut inner = <i32>::sse_decode(deserializer);
4213 return match inner {
4214 0 => crate::model::PaymentMethod::Lightning,
4215 1 => crate::model::PaymentMethod::Bolt11Invoice,
4216 2 => crate::model::PaymentMethod::Bolt12Offer,
4217 3 => crate::model::PaymentMethod::BitcoinAddress,
4218 4 => crate::model::PaymentMethod::LiquidAddress,
4219 _ => unreachable!("Invalid variant for PaymentMethod: {}", inner),
4220 };
4221 }
4222}
4223
4224impl SseDecode for crate::model::PaymentState {
4225 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4227 let mut inner = <i32>::sse_decode(deserializer);
4228 return match inner {
4229 0 => crate::model::PaymentState::Created,
4230 1 => crate::model::PaymentState::Pending,
4231 2 => crate::model::PaymentState::Complete,
4232 3 => crate::model::PaymentState::Failed,
4233 4 => crate::model::PaymentState::TimedOut,
4234 5 => crate::model::PaymentState::Refundable,
4235 6 => crate::model::PaymentState::RefundPending,
4236 7 => crate::model::PaymentState::WaitingFeeAcceptance,
4237 _ => unreachable!("Invalid variant for PaymentState: {}", inner),
4238 };
4239 }
4240}
4241
4242impl SseDecode for crate::model::PaymentType {
4243 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4245 let mut inner = <i32>::sse_decode(deserializer);
4246 return match inner {
4247 0 => crate::model::PaymentType::Receive,
4248 1 => crate::model::PaymentType::Send,
4249 _ => unreachable!("Invalid variant for PaymentType: {}", inner),
4250 };
4251 }
4252}
4253
4254impl SseDecode for crate::model::PrepareBuyBitcoinRequest {
4255 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4257 let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4258 let mut var_amountSat = <u64>::sse_decode(deserializer);
4259 return crate::model::PrepareBuyBitcoinRequest {
4260 provider: var_provider,
4261 amount_sat: var_amountSat,
4262 };
4263 }
4264}
4265
4266impl SseDecode for crate::model::PrepareBuyBitcoinResponse {
4267 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4269 let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4270 let mut var_amountSat = <u64>::sse_decode(deserializer);
4271 let mut var_feesSat = <u64>::sse_decode(deserializer);
4272 return crate::model::PrepareBuyBitcoinResponse {
4273 provider: var_provider,
4274 amount_sat: var_amountSat,
4275 fees_sat: var_feesSat,
4276 };
4277 }
4278}
4279
4280impl SseDecode for crate::model::PrepareLnUrlPayRequest {
4281 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4283 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4284 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4285 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4286 let mut var_comment = <Option<String>>::sse_decode(deserializer);
4287 let mut var_validateSuccessActionUrl = <Option<bool>>::sse_decode(deserializer);
4288 return crate::model::PrepareLnUrlPayRequest {
4289 data: var_data,
4290 amount: var_amount,
4291 bip353_address: var_bip353Address,
4292 comment: var_comment,
4293 validate_success_action_url: var_validateSuccessActionUrl,
4294 };
4295 }
4296}
4297
4298impl SseDecode for crate::model::PrepareLnUrlPayResponse {
4299 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4301 let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4302 let mut var_feesSat = <u64>::sse_decode(deserializer);
4303 let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4304 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4305 let mut var_comment = <Option<String>>::sse_decode(deserializer);
4306 let mut var_successAction =
4307 <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
4308 return crate::model::PrepareLnUrlPayResponse {
4309 destination: var_destination,
4310 fees_sat: var_feesSat,
4311 data: var_data,
4312 amount: var_amount,
4313 comment: var_comment,
4314 success_action: var_successAction,
4315 };
4316 }
4317}
4318
4319impl SseDecode for crate::model::PreparePayOnchainRequest {
4320 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4322 let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4323 let mut var_feeRateSatPerVbyte = <Option<u32>>::sse_decode(deserializer);
4324 return crate::model::PreparePayOnchainRequest {
4325 amount: var_amount,
4326 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4327 };
4328 }
4329}
4330
4331impl SseDecode for crate::model::PreparePayOnchainResponse {
4332 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4334 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4335 let mut var_claimFeesSat = <u64>::sse_decode(deserializer);
4336 let mut var_totalFeesSat = <u64>::sse_decode(deserializer);
4337 return crate::model::PreparePayOnchainResponse {
4338 receiver_amount_sat: var_receiverAmountSat,
4339 claim_fees_sat: var_claimFeesSat,
4340 total_fees_sat: var_totalFeesSat,
4341 };
4342 }
4343}
4344
4345impl SseDecode for crate::model::PrepareReceiveRequest {
4346 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4348 let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4349 let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4350 return crate::model::PrepareReceiveRequest {
4351 payment_method: var_paymentMethod,
4352 amount: var_amount,
4353 };
4354 }
4355}
4356
4357impl SseDecode for crate::model::PrepareReceiveResponse {
4358 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4360 let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4361 let mut var_feesSat = <u64>::sse_decode(deserializer);
4362 let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4363 let mut var_minPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4364 let mut var_maxPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4365 let mut var_swapperFeerate = <Option<f64>>::sse_decode(deserializer);
4366 return crate::model::PrepareReceiveResponse {
4367 payment_method: var_paymentMethod,
4368 fees_sat: var_feesSat,
4369 amount: var_amount,
4370 min_payer_amount_sat: var_minPayerAmountSat,
4371 max_payer_amount_sat: var_maxPayerAmountSat,
4372 swapper_feerate: var_swapperFeerate,
4373 };
4374 }
4375}
4376
4377impl SseDecode for crate::model::PrepareRefundRequest {
4378 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4380 let mut var_swapAddress = <String>::sse_decode(deserializer);
4381 let mut var_refundAddress = <String>::sse_decode(deserializer);
4382 let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4383 return crate::model::PrepareRefundRequest {
4384 swap_address: var_swapAddress,
4385 refund_address: var_refundAddress,
4386 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4387 };
4388 }
4389}
4390
4391impl SseDecode for crate::model::PrepareRefundResponse {
4392 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4394 let mut var_txVsize = <u32>::sse_decode(deserializer);
4395 let mut var_txFeeSat = <u64>::sse_decode(deserializer);
4396 let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4397 return crate::model::PrepareRefundResponse {
4398 tx_vsize: var_txVsize,
4399 tx_fee_sat: var_txFeeSat,
4400 last_refund_tx_id: var_lastRefundTxId,
4401 };
4402 }
4403}
4404
4405impl SseDecode for crate::model::PrepareSendRequest {
4406 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4408 let mut var_destination = <String>::sse_decode(deserializer);
4409 let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4410 return crate::model::PrepareSendRequest {
4411 destination: var_destination,
4412 amount: var_amount,
4413 };
4414 }
4415}
4416
4417impl SseDecode for crate::model::PrepareSendResponse {
4418 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4420 let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4421 let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4422 let mut var_feesSat = <Option<u64>>::sse_decode(deserializer);
4423 let mut var_estimatedAssetFees = <Option<f64>>::sse_decode(deserializer);
4424 return crate::model::PrepareSendResponse {
4425 destination: var_destination,
4426 amount: var_amount,
4427 fees_sat: var_feesSat,
4428 estimated_asset_fees: var_estimatedAssetFees,
4429 };
4430 }
4431}
4432
4433impl SseDecode for crate::bindings::Rate {
4434 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4436 let mut var_coin = <String>::sse_decode(deserializer);
4437 let mut var_value = <f64>::sse_decode(deserializer);
4438 return crate::bindings::Rate {
4439 coin: var_coin,
4440 value: var_value,
4441 };
4442 }
4443}
4444
4445impl SseDecode for crate::model::ReceiveAmount {
4446 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4448 let mut tag_ = <i32>::sse_decode(deserializer);
4449 match tag_ {
4450 0 => {
4451 let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
4452 return crate::model::ReceiveAmount::Bitcoin {
4453 payer_amount_sat: var_payerAmountSat,
4454 };
4455 }
4456 1 => {
4457 let mut var_assetId = <String>::sse_decode(deserializer);
4458 let mut var_payerAmount = <Option<f64>>::sse_decode(deserializer);
4459 return crate::model::ReceiveAmount::Asset {
4460 asset_id: var_assetId,
4461 payer_amount: var_payerAmount,
4462 };
4463 }
4464 _ => {
4465 unimplemented!("");
4466 }
4467 }
4468 }
4469}
4470
4471impl SseDecode for crate::model::ReceivePaymentRequest {
4472 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4474 let mut var_prepareResponse =
4475 <crate::model::PrepareReceiveResponse>::sse_decode(deserializer);
4476 let mut var_description = <Option<String>>::sse_decode(deserializer);
4477 let mut var_useDescriptionHash = <Option<bool>>::sse_decode(deserializer);
4478 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4479 return crate::model::ReceivePaymentRequest {
4480 prepare_response: var_prepareResponse,
4481 description: var_description,
4482 use_description_hash: var_useDescriptionHash,
4483 payer_note: var_payerNote,
4484 };
4485 }
4486}
4487
4488impl SseDecode for crate::model::ReceivePaymentResponse {
4489 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4491 let mut var_destination = <String>::sse_decode(deserializer);
4492 return crate::model::ReceivePaymentResponse {
4493 destination: var_destination,
4494 };
4495 }
4496}
4497
4498impl SseDecode for crate::model::RecommendedFees {
4499 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4501 let mut var_fastestFee = <u64>::sse_decode(deserializer);
4502 let mut var_halfHourFee = <u64>::sse_decode(deserializer);
4503 let mut var_hourFee = <u64>::sse_decode(deserializer);
4504 let mut var_economyFee = <u64>::sse_decode(deserializer);
4505 let mut var_minimumFee = <u64>::sse_decode(deserializer);
4506 return crate::model::RecommendedFees {
4507 fastest_fee: var_fastestFee,
4508 half_hour_fee: var_halfHourFee,
4509 hour_fee: var_hourFee,
4510 economy_fee: var_economyFee,
4511 minimum_fee: var_minimumFee,
4512 };
4513 }
4514}
4515
4516impl SseDecode for crate::model::RefundRequest {
4517 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4519 let mut var_swapAddress = <String>::sse_decode(deserializer);
4520 let mut var_refundAddress = <String>::sse_decode(deserializer);
4521 let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4522 return crate::model::RefundRequest {
4523 swap_address: var_swapAddress,
4524 refund_address: var_refundAddress,
4525 fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4526 };
4527 }
4528}
4529
4530impl SseDecode for crate::model::RefundResponse {
4531 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4533 let mut var_refundTxId = <String>::sse_decode(deserializer);
4534 return crate::model::RefundResponse {
4535 refund_tx_id: var_refundTxId,
4536 };
4537 }
4538}
4539
4540impl SseDecode for crate::model::RefundableSwap {
4541 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4543 let mut var_swapAddress = <String>::sse_decode(deserializer);
4544 let mut var_timestamp = <u32>::sse_decode(deserializer);
4545 let mut var_amountSat = <u64>::sse_decode(deserializer);
4546 let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4547 return crate::model::RefundableSwap {
4548 swap_address: var_swapAddress,
4549 timestamp: var_timestamp,
4550 amount_sat: var_amountSat,
4551 last_refund_tx_id: var_lastRefundTxId,
4552 };
4553 }
4554}
4555
4556impl SseDecode for crate::model::RestoreRequest {
4557 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4559 let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
4560 return crate::model::RestoreRequest {
4561 backup_path: var_backupPath,
4562 };
4563 }
4564}
4565
4566impl SseDecode for crate::bindings::RouteHint {
4567 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4569 let mut var_hops = <Vec<crate::bindings::RouteHintHop>>::sse_decode(deserializer);
4570 return crate::bindings::RouteHint { hops: var_hops };
4571 }
4572}
4573
4574impl SseDecode for crate::bindings::RouteHintHop {
4575 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4577 let mut var_srcNodeId = <String>::sse_decode(deserializer);
4578 let mut var_shortChannelId = <String>::sse_decode(deserializer);
4579 let mut var_feesBaseMsat = <u32>::sse_decode(deserializer);
4580 let mut var_feesProportionalMillionths = <u32>::sse_decode(deserializer);
4581 let mut var_cltvExpiryDelta = <u64>::sse_decode(deserializer);
4582 let mut var_htlcMinimumMsat = <Option<u64>>::sse_decode(deserializer);
4583 let mut var_htlcMaximumMsat = <Option<u64>>::sse_decode(deserializer);
4584 return crate::bindings::RouteHintHop {
4585 src_node_id: var_srcNodeId,
4586 short_channel_id: var_shortChannelId,
4587 fees_base_msat: var_feesBaseMsat,
4588 fees_proportional_millionths: var_feesProportionalMillionths,
4589 cltv_expiry_delta: var_cltvExpiryDelta,
4590 htlc_minimum_msat: var_htlcMinimumMsat,
4591 htlc_maximum_msat: var_htlcMaximumMsat,
4592 };
4593 }
4594}
4595
4596impl SseDecode for crate::error::SdkError {
4597 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4599 let mut tag_ = <i32>::sse_decode(deserializer);
4600 match tag_ {
4601 0 => {
4602 return crate::error::SdkError::AlreadyStarted;
4603 }
4604 1 => {
4605 let mut var_err = <String>::sse_decode(deserializer);
4606 return crate::error::SdkError::Generic { err: var_err };
4607 }
4608 2 => {
4609 return crate::error::SdkError::NotStarted;
4610 }
4611 3 => {
4612 let mut var_err = <String>::sse_decode(deserializer);
4613 return crate::error::SdkError::ServiceConnectivity { err: var_err };
4614 }
4615 _ => {
4616 unimplemented!("");
4617 }
4618 }
4619 }
4620}
4621
4622impl SseDecode for crate::model::SdkEvent {
4623 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4625 let mut tag_ = <i32>::sse_decode(deserializer);
4626 match tag_ {
4627 0 => {
4628 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4629 return crate::model::SdkEvent::PaymentFailed {
4630 details: var_details,
4631 };
4632 }
4633 1 => {
4634 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4635 return crate::model::SdkEvent::PaymentPending {
4636 details: var_details,
4637 };
4638 }
4639 2 => {
4640 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4641 return crate::model::SdkEvent::PaymentRefundable {
4642 details: var_details,
4643 };
4644 }
4645 3 => {
4646 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4647 return crate::model::SdkEvent::PaymentRefunded {
4648 details: var_details,
4649 };
4650 }
4651 4 => {
4652 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4653 return crate::model::SdkEvent::PaymentRefundPending {
4654 details: var_details,
4655 };
4656 }
4657 5 => {
4658 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4659 return crate::model::SdkEvent::PaymentSucceeded {
4660 details: var_details,
4661 };
4662 }
4663 6 => {
4664 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4665 return crate::model::SdkEvent::PaymentWaitingConfirmation {
4666 details: var_details,
4667 };
4668 }
4669 7 => {
4670 let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4671 return crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
4672 details: var_details,
4673 };
4674 }
4675 8 => {
4676 return crate::model::SdkEvent::Synced;
4677 }
4678 9 => {
4679 let mut var_didPullNewRecords = <bool>::sse_decode(deserializer);
4680 return crate::model::SdkEvent::DataSynced {
4681 did_pull_new_records: var_didPullNewRecords,
4682 };
4683 }
4684 _ => {
4685 unimplemented!("");
4686 }
4687 }
4688 }
4689}
4690
4691impl SseDecode for crate::model::SendDestination {
4692 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4694 let mut tag_ = <i32>::sse_decode(deserializer);
4695 match tag_ {
4696 0 => {
4697 let mut var_addressData =
4698 <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
4699 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4700 return crate::model::SendDestination::LiquidAddress {
4701 address_data: var_addressData,
4702 bip353_address: var_bip353Address,
4703 };
4704 }
4705 1 => {
4706 let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
4707 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4708 return crate::model::SendDestination::Bolt11 {
4709 invoice: var_invoice,
4710 bip353_address: var_bip353Address,
4711 };
4712 }
4713 2 => {
4714 let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
4715 let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4716 let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4717 return crate::model::SendDestination::Bolt12 {
4718 offer: var_offer,
4719 receiver_amount_sat: var_receiverAmountSat,
4720 bip353_address: var_bip353Address,
4721 };
4722 }
4723 _ => {
4724 unimplemented!("");
4725 }
4726 }
4727 }
4728}
4729
4730impl SseDecode for crate::model::SendPaymentRequest {
4731 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4733 let mut var_prepareResponse = <crate::model::PrepareSendResponse>::sse_decode(deserializer);
4734 let mut var_useAssetFees = <Option<bool>>::sse_decode(deserializer);
4735 let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4736 return crate::model::SendPaymentRequest {
4737 prepare_response: var_prepareResponse,
4738 use_asset_fees: var_useAssetFees,
4739 payer_note: var_payerNote,
4740 };
4741 }
4742}
4743
4744impl SseDecode for crate::model::SendPaymentResponse {
4745 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4747 let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
4748 return crate::model::SendPaymentResponse {
4749 payment: var_payment,
4750 };
4751 }
4752}
4753
4754impl SseDecode for crate::model::SignMessageRequest {
4755 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4757 let mut var_message = <String>::sse_decode(deserializer);
4758 return crate::model::SignMessageRequest {
4759 message: var_message,
4760 };
4761 }
4762}
4763
4764impl SseDecode for crate::model::SignMessageResponse {
4765 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4767 let mut var_signature = <String>::sse_decode(deserializer);
4768 return crate::model::SignMessageResponse {
4769 signature: var_signature,
4770 };
4771 }
4772}
4773
4774impl SseDecode for crate::bindings::SuccessAction {
4775 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4777 let mut tag_ = <i32>::sse_decode(deserializer);
4778 match tag_ {
4779 0 => {
4780 let mut var_data =
4781 <crate::bindings::AesSuccessActionData>::sse_decode(deserializer);
4782 return crate::bindings::SuccessAction::Aes { data: var_data };
4783 }
4784 1 => {
4785 let mut var_data =
4786 <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4787 return crate::bindings::SuccessAction::Message { data: var_data };
4788 }
4789 2 => {
4790 let mut var_data =
4791 <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4792 return crate::bindings::SuccessAction::Url { data: var_data };
4793 }
4794 _ => {
4795 unimplemented!("");
4796 }
4797 }
4798 }
4799}
4800
4801impl SseDecode for crate::bindings::SuccessActionProcessed {
4802 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4804 let mut tag_ = <i32>::sse_decode(deserializer);
4805 match tag_ {
4806 0 => {
4807 let mut var_result =
4808 <crate::bindings::AesSuccessActionDataResult>::sse_decode(deserializer);
4809 return crate::bindings::SuccessActionProcessed::Aes { result: var_result };
4810 }
4811 1 => {
4812 let mut var_data =
4813 <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4814 return crate::bindings::SuccessActionProcessed::Message { data: var_data };
4815 }
4816 2 => {
4817 let mut var_data =
4818 <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4819 return crate::bindings::SuccessActionProcessed::Url { data: var_data };
4820 }
4821 _ => {
4822 unimplemented!("");
4823 }
4824 }
4825 }
4826}
4827
4828impl SseDecode for crate::bindings::Symbol {
4829 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4831 let mut var_grapheme = <Option<String>>::sse_decode(deserializer);
4832 let mut var_template = <Option<String>>::sse_decode(deserializer);
4833 let mut var_rtl = <Option<bool>>::sse_decode(deserializer);
4834 let mut var_position = <Option<u32>>::sse_decode(deserializer);
4835 return crate::bindings::Symbol {
4836 grapheme: var_grapheme,
4837 template: var_template,
4838 rtl: var_rtl,
4839 position: var_position,
4840 };
4841 }
4842}
4843
4844impl SseDecode for u16 {
4845 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4847 deserializer.cursor.read_u16::<NativeEndian>().unwrap()
4848 }
4849}
4850
4851impl SseDecode for u32 {
4852 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4854 deserializer.cursor.read_u32::<NativeEndian>().unwrap()
4855 }
4856}
4857
4858impl SseDecode for u64 {
4859 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4861 deserializer.cursor.read_u64::<NativeEndian>().unwrap()
4862 }
4863}
4864
4865impl SseDecode for u8 {
4866 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4868 deserializer.cursor.read_u8().unwrap()
4869 }
4870}
4871
4872impl SseDecode for () {
4873 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
4875}
4876
4877impl SseDecode for crate::bindings::UrlSuccessActionData {
4878 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4880 let mut var_description = <String>::sse_decode(deserializer);
4881 let mut var_url = <String>::sse_decode(deserializer);
4882 let mut var_matchesCallbackDomain = <bool>::sse_decode(deserializer);
4883 return crate::bindings::UrlSuccessActionData {
4884 description: var_description,
4885 url: var_url,
4886 matches_callback_domain: var_matchesCallbackDomain,
4887 };
4888 }
4889}
4890
4891impl SseDecode for usize {
4892 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4894 deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
4895 }
4896}
4897
4898impl SseDecode for crate::model::WalletInfo {
4899 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4901 let mut var_balanceSat = <u64>::sse_decode(deserializer);
4902 let mut var_pendingSendSat = <u64>::sse_decode(deserializer);
4903 let mut var_pendingReceiveSat = <u64>::sse_decode(deserializer);
4904 let mut var_fingerprint = <String>::sse_decode(deserializer);
4905 let mut var_pubkey = <String>::sse_decode(deserializer);
4906 let mut var_assetBalances = <Vec<crate::model::AssetBalance>>::sse_decode(deserializer);
4907 return crate::model::WalletInfo {
4908 balance_sat: var_balanceSat,
4909 pending_send_sat: var_pendingSendSat,
4910 pending_receive_sat: var_pendingReceiveSat,
4911 fingerprint: var_fingerprint,
4912 pubkey: var_pubkey,
4913 asset_balances: var_assetBalances,
4914 };
4915 }
4916}
4917
4918fn pde_ffi_dispatcher_primary_impl(
4919 func_id: i32,
4920 port: flutter_rust_bridge::for_generated::MessagePort,
4921 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4922 rust_vec_len: i32,
4923 data_len: i32,
4924) {
4925 match func_id {
4927 _ => unreachable!(),
4928 }
4929}
4930
4931fn pde_ffi_dispatcher_sync_impl(
4932 func_id: i32,
4933 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4934 rust_vec_len: i32,
4935 data_len: i32,
4936) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
4937 match func_id {
4939 _ => unreachable!(),
4940 }
4941}
4942
4943impl flutter_rust_bridge::IntoDart for FrbWrapper<BindingLiquidSdk> {
4947 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4948 flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0)
4949 .into_dart()
4950 }
4951}
4952impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<BindingLiquidSdk> {}
4953
4954impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<BindingLiquidSdk>> for BindingLiquidSdk {
4955 fn into_into_dart(self) -> FrbWrapper<BindingLiquidSdk> {
4956 self.into()
4957 }
4958}
4959
4960impl flutter_rust_bridge::IntoDart for crate::model::AcceptPaymentProposedFeesRequest {
4962 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4963 [self.response.into_into_dart().into_dart()].into_dart()
4964 }
4965}
4966impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4967 for crate::model::AcceptPaymentProposedFeesRequest
4968{
4969}
4970impl flutter_rust_bridge::IntoIntoDart<crate::model::AcceptPaymentProposedFeesRequest>
4971 for crate::model::AcceptPaymentProposedFeesRequest
4972{
4973 fn into_into_dart(self) -> crate::model::AcceptPaymentProposedFeesRequest {
4974 self
4975 }
4976}
4977impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionData> {
4979 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4980 [
4981 self.0.description.into_into_dart().into_dart(),
4982 self.0.ciphertext.into_into_dart().into_dart(),
4983 self.0.iv.into_into_dart().into_dart(),
4984 ]
4985 .into_dart()
4986 }
4987}
4988impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4989 for FrbWrapper<crate::bindings::AesSuccessActionData>
4990{
4991}
4992impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionData>>
4993 for crate::bindings::AesSuccessActionData
4994{
4995 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionData> {
4996 self.into()
4997 }
4998}
4999impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5001 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5002 [
5003 self.0.description.into_into_dart().into_dart(),
5004 self.0.plaintext.into_into_dart().into_dart(),
5005 ]
5006 .into_dart()
5007 }
5008}
5009impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5010 for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>
5011{
5012}
5013impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>>
5014 for crate::bindings::AesSuccessActionDataDecrypted
5015{
5016 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5017 self.into()
5018 }
5019}
5020impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5022 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5023 match self.0 {
5024 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
5025 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
5026 }
5027 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
5028 [1.into_dart(), reason.into_into_dart().into_dart()].into_dart()
5029 }
5030 _ => {
5031 unimplemented!("");
5032 }
5033 }
5034 }
5035}
5036impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5037 for FrbWrapper<crate::bindings::AesSuccessActionDataResult>
5038{
5039}
5040impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataResult>>
5041 for crate::bindings::AesSuccessActionDataResult
5042{
5043 fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5044 self.into()
5045 }
5046}
5047impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Amount> {
5049 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5050 match self.0 {
5051 crate::bindings::Amount::Bitcoin { amount_msat } => {
5052 [0.into_dart(), amount_msat.into_into_dart().into_dart()].into_dart()
5053 }
5054 crate::bindings::Amount::Currency {
5055 iso4217_code,
5056 fractional_amount,
5057 } => [
5058 1.into_dart(),
5059 iso4217_code.into_into_dart().into_dart(),
5060 fractional_amount.into_into_dart().into_dart(),
5061 ]
5062 .into_dart(),
5063 _ => {
5064 unimplemented!("");
5065 }
5066 }
5067 }
5068}
5069impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5070 for FrbWrapper<crate::bindings::Amount>
5071{
5072}
5073impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Amount>>
5074 for crate::bindings::Amount
5075{
5076 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Amount> {
5077 self.into()
5078 }
5079}
5080impl flutter_rust_bridge::IntoDart for crate::model::AssetBalance {
5082 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5083 [
5084 self.asset_id.into_into_dart().into_dart(),
5085 self.balance_sat.into_into_dart().into_dart(),
5086 self.name.into_into_dart().into_dart(),
5087 self.ticker.into_into_dart().into_dart(),
5088 self.balance.into_into_dart().into_dart(),
5089 ]
5090 .into_dart()
5091 }
5092}
5093impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetBalance {}
5094impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetBalance> for crate::model::AssetBalance {
5095 fn into_into_dart(self) -> crate::model::AssetBalance {
5096 self
5097 }
5098}
5099impl flutter_rust_bridge::IntoDart for crate::model::AssetInfo {
5101 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5102 [
5103 self.name.into_into_dart().into_dart(),
5104 self.ticker.into_into_dart().into_dart(),
5105 self.amount.into_into_dart().into_dart(),
5106 self.fees.into_into_dart().into_dart(),
5107 ]
5108 .into_dart()
5109 }
5110}
5111impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetInfo {}
5112impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetInfo> for crate::model::AssetInfo {
5113 fn into_into_dart(self) -> crate::model::AssetInfo {
5114 self
5115 }
5116}
5117impl flutter_rust_bridge::IntoDart for crate::model::AssetMetadata {
5119 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5120 [
5121 self.asset_id.into_into_dart().into_dart(),
5122 self.name.into_into_dart().into_dart(),
5123 self.ticker.into_into_dart().into_dart(),
5124 self.precision.into_into_dart().into_dart(),
5125 self.fiat_id.into_into_dart().into_dart(),
5126 ]
5127 .into_dart()
5128 }
5129}
5130impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetMetadata {}
5131impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetMetadata>
5132 for crate::model::AssetMetadata
5133{
5134 fn into_into_dart(self) -> crate::model::AssetMetadata {
5135 self
5136 }
5137}
5138impl flutter_rust_bridge::IntoDart for crate::model::BackupRequest {
5140 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5141 [self.backup_path.into_into_dart().into_dart()].into_dart()
5142 }
5143}
5144impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BackupRequest {}
5145impl flutter_rust_bridge::IntoIntoDart<crate::model::BackupRequest>
5146 for crate::model::BackupRequest
5147{
5148 fn into_into_dart(self) -> crate::model::BackupRequest {
5149 self
5150 }
5151}
5152impl flutter_rust_bridge::IntoDart for crate::bindings::BindingEventListener {
5154 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5155 [self.stream.into_into_dart().into_dart()].into_dart()
5156 }
5157}
5158impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5159 for crate::bindings::BindingEventListener
5160{
5161}
5162impl flutter_rust_bridge::IntoIntoDart<crate::bindings::BindingEventListener>
5163 for crate::bindings::BindingEventListener
5164{
5165 fn into_into_dart(self) -> crate::bindings::BindingEventListener {
5166 self
5167 }
5168}
5169impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::BitcoinAddressData> {
5171 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5172 [
5173 self.0.address.into_into_dart().into_dart(),
5174 self.0.network.into_into_dart().into_dart(),
5175 self.0.amount_sat.into_into_dart().into_dart(),
5176 self.0.label.into_into_dart().into_dart(),
5177 self.0.message.into_into_dart().into_dart(),
5178 ]
5179 .into_dart()
5180 }
5181}
5182impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5183 for FrbWrapper<crate::bindings::BitcoinAddressData>
5184{
5185}
5186impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::BitcoinAddressData>>
5187 for crate::bindings::BitcoinAddressData
5188{
5189 fn into_into_dart(self) -> FrbWrapper<crate::bindings::BitcoinAddressData> {
5190 self.into()
5191 }
5192}
5193impl flutter_rust_bridge::IntoDart for crate::model::BlockchainExplorer {
5195 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5196 match self {
5197 crate::model::BlockchainExplorer::Electrum { url } => {
5198 [0.into_dart(), url.into_into_dart().into_dart()].into_dart()
5199 }
5200 crate::model::BlockchainExplorer::Esplora {
5201 url,
5202 use_waterfalls,
5203 } => [
5204 1.into_dart(),
5205 url.into_into_dart().into_dart(),
5206 use_waterfalls.into_into_dart().into_dart(),
5207 ]
5208 .into_dart(),
5209 _ => {
5210 unimplemented!("");
5211 }
5212 }
5213 }
5214}
5215impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5216 for crate::model::BlockchainExplorer
5217{
5218}
5219impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainExplorer>
5220 for crate::model::BlockchainExplorer
5221{
5222 fn into_into_dart(self) -> crate::model::BlockchainExplorer {
5223 self
5224 }
5225}
5226impl flutter_rust_bridge::IntoDart for crate::model::BlockchainInfo {
5228 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5229 [
5230 self.liquid_tip.into_into_dart().into_dart(),
5231 self.bitcoin_tip.into_into_dart().into_dart(),
5232 ]
5233 .into_dart()
5234 }
5235}
5236impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BlockchainInfo {}
5237impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainInfo>
5238 for crate::model::BlockchainInfo
5239{
5240 fn into_into_dart(self) -> crate::model::BlockchainInfo {
5241 self
5242 }
5243}
5244impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinProvider {
5246 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5247 match self {
5248 Self::Moonpay => 0.into_dart(),
5249 _ => unreachable!(),
5250 }
5251 }
5252}
5253impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5254 for crate::model::BuyBitcoinProvider
5255{
5256}
5257impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinProvider>
5258 for crate::model::BuyBitcoinProvider
5259{
5260 fn into_into_dart(self) -> crate::model::BuyBitcoinProvider {
5261 self
5262 }
5263}
5264impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinRequest {
5266 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5267 [
5268 self.prepare_response.into_into_dart().into_dart(),
5269 self.redirect_url.into_into_dart().into_dart(),
5270 ]
5271 .into_dart()
5272 }
5273}
5274impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5275 for crate::model::BuyBitcoinRequest
5276{
5277}
5278impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinRequest>
5279 for crate::model::BuyBitcoinRequest
5280{
5281 fn into_into_dart(self) -> crate::model::BuyBitcoinRequest {
5282 self
5283 }
5284}
5285impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageRequest {
5287 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5288 [
5289 self.message.into_into_dart().into_dart(),
5290 self.pubkey.into_into_dart().into_dart(),
5291 self.signature.into_into_dart().into_dart(),
5292 ]
5293 .into_dart()
5294 }
5295}
5296impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5297 for crate::model::CheckMessageRequest
5298{
5299}
5300impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageRequest>
5301 for crate::model::CheckMessageRequest
5302{
5303 fn into_into_dart(self) -> crate::model::CheckMessageRequest {
5304 self
5305 }
5306}
5307impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageResponse {
5309 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5310 [self.is_valid.into_into_dart().into_dart()].into_dart()
5311 }
5312}
5313impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5314 for crate::model::CheckMessageResponse
5315{
5316}
5317impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageResponse>
5318 for crate::model::CheckMessageResponse
5319{
5320 fn into_into_dart(self) -> crate::model::CheckMessageResponse {
5321 self
5322 }
5323}
5324impl flutter_rust_bridge::IntoDart for crate::model::Config {
5326 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5327 [
5328 self.liquid_explorer.into_into_dart().into_dart(),
5329 self.bitcoin_explorer.into_into_dart().into_dart(),
5330 self.working_dir.into_into_dart().into_dart(),
5331 self.network.into_into_dart().into_dart(),
5332 self.payment_timeout_sec.into_into_dart().into_dart(),
5333 self.sync_service_url.into_into_dart().into_dart(),
5334 self.zero_conf_max_amount_sat.into_into_dart().into_dart(),
5335 self.breez_api_key.into_into_dart().into_dart(),
5336 self.external_input_parsers.into_into_dart().into_dart(),
5337 self.use_default_external_input_parsers
5338 .into_into_dart()
5339 .into_dart(),
5340 self.onchain_fee_rate_leeway_sat
5341 .into_into_dart()
5342 .into_dart(),
5343 self.asset_metadata.into_into_dart().into_dart(),
5344 self.sideswap_api_key.into_into_dart().into_dart(),
5345 ]
5346 .into_dart()
5347 }
5348}
5349impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Config {}
5350impl flutter_rust_bridge::IntoIntoDart<crate::model::Config> for crate::model::Config {
5351 fn into_into_dart(self) -> crate::model::Config {
5352 self
5353 }
5354}
5355impl flutter_rust_bridge::IntoDart for crate::model::ConnectRequest {
5357 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5358 [
5359 self.config.into_into_dart().into_dart(),
5360 self.mnemonic.into_into_dart().into_dart(),
5361 self.passphrase.into_into_dart().into_dart(),
5362 self.seed.into_into_dart().into_dart(),
5363 ]
5364 .into_dart()
5365 }
5366}
5367impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ConnectRequest {}
5368impl flutter_rust_bridge::IntoIntoDart<crate::model::ConnectRequest>
5369 for crate::model::ConnectRequest
5370{
5371 fn into_into_dart(self) -> crate::model::ConnectRequest {
5372 self
5373 }
5374}
5375impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceRequest {
5377 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5378 [
5379 self.offer.into_into_dart().into_dart(),
5380 self.invoice_request.into_into_dart().into_dart(),
5381 ]
5382 .into_dart()
5383 }
5384}
5385impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5386 for crate::model::CreateBolt12InvoiceRequest
5387{
5388}
5389impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceRequest>
5390 for crate::model::CreateBolt12InvoiceRequest
5391{
5392 fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceRequest {
5393 self
5394 }
5395}
5396impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceResponse {
5398 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5399 [self.invoice.into_into_dart().into_dart()].into_dart()
5400 }
5401}
5402impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5403 for crate::model::CreateBolt12InvoiceResponse
5404{
5405}
5406impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceResponse>
5407 for crate::model::CreateBolt12InvoiceResponse
5408{
5409 fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceResponse {
5410 self
5411 }
5412}
5413impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::CurrencyInfo> {
5415 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5416 [
5417 self.0.name.into_into_dart().into_dart(),
5418 self.0.fraction_size.into_into_dart().into_dart(),
5419 self.0.spacing.into_into_dart().into_dart(),
5420 self.0.symbol.into_into_dart().into_dart(),
5421 self.0.uniq_symbol.into_into_dart().into_dart(),
5422 self.0.localized_name.into_into_dart().into_dart(),
5423 self.0.locale_overrides.into_into_dart().into_dart(),
5424 ]
5425 .into_dart()
5426 }
5427}
5428impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5429 for FrbWrapper<crate::bindings::CurrencyInfo>
5430{
5431}
5432impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::CurrencyInfo>>
5433 for crate::bindings::CurrencyInfo
5434{
5435 fn into_into_dart(self) -> FrbWrapper<crate::bindings::CurrencyInfo> {
5436 self.into()
5437 }
5438}
5439impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::ExternalInputParser> {
5441 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5442 [
5443 self.0.provider_id.into_into_dart().into_dart(),
5444 self.0.input_regex.into_into_dart().into_dart(),
5445 self.0.parser_url.into_into_dart().into_dart(),
5446 ]
5447 .into_dart()
5448 }
5449}
5450impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5451 for FrbWrapper<crate::bindings::ExternalInputParser>
5452{
5453}
5454impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::ExternalInputParser>>
5455 for crate::bindings::ExternalInputParser
5456{
5457 fn into_into_dart(self) -> FrbWrapper<crate::bindings::ExternalInputParser> {
5458 self.into()
5459 }
5460}
5461impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesRequest {
5463 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5464 [self.swap_id.into_into_dart().into_dart()].into_dart()
5465 }
5466}
5467impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5468 for crate::model::FetchPaymentProposedFeesRequest
5469{
5470}
5471impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesRequest>
5472 for crate::model::FetchPaymentProposedFeesRequest
5473{
5474 fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesRequest {
5475 self
5476 }
5477}
5478impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesResponse {
5480 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5481 [
5482 self.swap_id.into_into_dart().into_dart(),
5483 self.fees_sat.into_into_dart().into_dart(),
5484 self.payer_amount_sat.into_into_dart().into_dart(),
5485 self.receiver_amount_sat.into_into_dart().into_dart(),
5486 ]
5487 .into_dart()
5488 }
5489}
5490impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5491 for crate::model::FetchPaymentProposedFeesResponse
5492{
5493}
5494impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesResponse>
5495 for crate::model::FetchPaymentProposedFeesResponse
5496{
5497 fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesResponse {
5498 self
5499 }
5500}
5501impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::FiatCurrency> {
5503 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5504 [
5505 self.0.id.into_into_dart().into_dart(),
5506 self.0.info.into_into_dart().into_dart(),
5507 ]
5508 .into_dart()
5509 }
5510}
5511impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5512 for FrbWrapper<crate::bindings::FiatCurrency>
5513{
5514}
5515impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::FiatCurrency>>
5516 for crate::bindings::FiatCurrency
5517{
5518 fn into_into_dart(self) -> FrbWrapper<crate::bindings::FiatCurrency> {
5519 self.into()
5520 }
5521}
5522impl flutter_rust_bridge::IntoDart for crate::model::GetInfoResponse {
5524 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5525 [
5526 self.wallet_info.into_into_dart().into_dart(),
5527 self.blockchain_info.into_into_dart().into_dart(),
5528 ]
5529 .into_dart()
5530 }
5531}
5532impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::GetInfoResponse {}
5533impl flutter_rust_bridge::IntoIntoDart<crate::model::GetInfoResponse>
5534 for crate::model::GetInfoResponse
5535{
5536 fn into_into_dart(self) -> crate::model::GetInfoResponse {
5537 self
5538 }
5539}
5540impl flutter_rust_bridge::IntoDart for crate::model::GetPaymentRequest {
5542 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5543 match self {
5544 crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
5545 [0.into_dart(), payment_hash.into_into_dart().into_dart()].into_dart()
5546 }
5547 crate::model::GetPaymentRequest::SwapId { swap_id } => {
5548 [1.into_dart(), swap_id.into_into_dart().into_dart()].into_dart()
5549 }
5550 _ => {
5551 unimplemented!("");
5552 }
5553 }
5554 }
5555}
5556impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5557 for crate::model::GetPaymentRequest
5558{
5559}
5560impl flutter_rust_bridge::IntoIntoDart<crate::model::GetPaymentRequest>
5561 for crate::model::GetPaymentRequest
5562{
5563 fn into_into_dart(self) -> crate::model::GetPaymentRequest {
5564 self
5565 }
5566}
5567impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::InputType> {
5569 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5570 match self.0 {
5571 crate::bindings::InputType::BitcoinAddress { address } => {
5572 [0.into_dart(), address.into_into_dart().into_dart()].into_dart()
5573 }
5574 crate::bindings::InputType::LiquidAddress { address } => {
5575 [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5576 }
5577 crate::bindings::InputType::Bolt11 { invoice } => {
5578 [2.into_dart(), invoice.into_into_dart().into_dart()].into_dart()
5579 }
5580 crate::bindings::InputType::Bolt12Offer {
5581 offer,
5582 bip353_address,
5583 } => [
5584 3.into_dart(),
5585 offer.into_into_dart().into_dart(),
5586 bip353_address.into_into_dart().into_dart(),
5587 ]
5588 .into_dart(),
5589 crate::bindings::InputType::NodeId { node_id } => {
5590 [4.into_dart(), node_id.into_into_dart().into_dart()].into_dart()
5591 }
5592 crate::bindings::InputType::Url { url } => {
5593 [5.into_dart(), url.into_into_dart().into_dart()].into_dart()
5594 }
5595 crate::bindings::InputType::LnUrlPay {
5596 data,
5597 bip353_address,
5598 } => [
5599 6.into_dart(),
5600 data.into_into_dart().into_dart(),
5601 bip353_address.into_into_dart().into_dart(),
5602 ]
5603 .into_dart(),
5604 crate::bindings::InputType::LnUrlWithdraw { data } => {
5605 [7.into_dart(), data.into_into_dart().into_dart()].into_dart()
5606 }
5607 crate::bindings::InputType::LnUrlAuth { data } => {
5608 [8.into_dart(), data.into_into_dart().into_dart()].into_dart()
5609 }
5610 crate::bindings::InputType::LnUrlError { data } => {
5611 [9.into_dart(), data.into_into_dart().into_dart()].into_dart()
5612 }
5613 _ => {
5614 unimplemented!("");
5615 }
5616 }
5617 }
5618}
5619impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5620 for FrbWrapper<crate::bindings::InputType>
5621{
5622}
5623impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::InputType>>
5624 for crate::bindings::InputType
5625{
5626 fn into_into_dart(self) -> FrbWrapper<crate::bindings::InputType> {
5627 self.into()
5628 }
5629}
5630impl flutter_rust_bridge::IntoDart for crate::model::LightningPaymentLimitsResponse {
5632 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5633 [
5634 self.send.into_into_dart().into_dart(),
5635 self.receive.into_into_dart().into_dart(),
5636 ]
5637 .into_dart()
5638 }
5639}
5640impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5641 for crate::model::LightningPaymentLimitsResponse
5642{
5643}
5644impl flutter_rust_bridge::IntoIntoDart<crate::model::LightningPaymentLimitsResponse>
5645 for crate::model::LightningPaymentLimitsResponse
5646{
5647 fn into_into_dart(self) -> crate::model::LightningPaymentLimitsResponse {
5648 self
5649 }
5650}
5651impl flutter_rust_bridge::IntoDart for crate::model::Limits {
5653 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5654 [
5655 self.min_sat.into_into_dart().into_dart(),
5656 self.max_sat.into_into_dart().into_dart(),
5657 self.max_zero_conf_sat.into_into_dart().into_dart(),
5658 ]
5659 .into_dart()
5660 }
5661}
5662impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Limits {}
5663impl flutter_rust_bridge::IntoIntoDart<crate::model::Limits> for crate::model::Limits {
5664 fn into_into_dart(self) -> crate::model::Limits {
5665 self
5666 }
5667}
5668impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LiquidAddressData> {
5670 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5671 [
5672 self.0.address.into_into_dart().into_dart(),
5673 self.0.network.into_into_dart().into_dart(),
5674 self.0.asset_id.into_into_dart().into_dart(),
5675 self.0.amount.into_into_dart().into_dart(),
5676 self.0.amount_sat.into_into_dart().into_dart(),
5677 self.0.label.into_into_dart().into_dart(),
5678 self.0.message.into_into_dart().into_dart(),
5679 ]
5680 .into_dart()
5681 }
5682}
5683impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5684 for FrbWrapper<crate::bindings::LiquidAddressData>
5685{
5686}
5687impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LiquidAddressData>>
5688 for crate::bindings::LiquidAddressData
5689{
5690 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LiquidAddressData> {
5691 self.into()
5692 }
5693}
5694impl flutter_rust_bridge::IntoDart for crate::model::LiquidNetwork {
5696 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5697 match self {
5698 Self::Mainnet => 0.into_dart(),
5699 Self::Testnet => 1.into_dart(),
5700 Self::Regtest => 2.into_dart(),
5701 _ => unreachable!(),
5702 }
5703 }
5704}
5705impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LiquidNetwork {}
5706impl flutter_rust_bridge::IntoIntoDart<crate::model::LiquidNetwork>
5707 for crate::model::LiquidNetwork
5708{
5709 fn into_into_dart(self) -> crate::model::LiquidNetwork {
5710 self
5711 }
5712}
5713impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentDetails {
5715 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5716 match self {
5717 crate::model::ListPaymentDetails::Liquid {
5718 asset_id,
5719 destination,
5720 } => [
5721 0.into_dart(),
5722 asset_id.into_into_dart().into_dart(),
5723 destination.into_into_dart().into_dart(),
5724 ]
5725 .into_dart(),
5726 crate::model::ListPaymentDetails::Bitcoin { address } => {
5727 [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5728 }
5729 _ => {
5730 unimplemented!("");
5731 }
5732 }
5733 }
5734}
5735impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5736 for crate::model::ListPaymentDetails
5737{
5738}
5739impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentDetails>
5740 for crate::model::ListPaymentDetails
5741{
5742 fn into_into_dart(self) -> crate::model::ListPaymentDetails {
5743 self
5744 }
5745}
5746impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentsRequest {
5748 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5749 [
5750 self.filters.into_into_dart().into_dart(),
5751 self.states.into_into_dart().into_dart(),
5752 self.from_timestamp.into_into_dart().into_dart(),
5753 self.to_timestamp.into_into_dart().into_dart(),
5754 self.offset.into_into_dart().into_dart(),
5755 self.limit.into_into_dart().into_dart(),
5756 self.details.into_into_dart().into_dart(),
5757 self.sort_ascending.into_into_dart().into_dart(),
5758 ]
5759 .into_dart()
5760 }
5761}
5762impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5763 for crate::model::ListPaymentsRequest
5764{
5765}
5766impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentsRequest>
5767 for crate::model::ListPaymentsRequest
5768{
5769 fn into_into_dart(self) -> crate::model::ListPaymentsRequest {
5770 self
5771 }
5772}
5773impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNInvoice> {
5775 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5776 [
5777 self.0.bolt11.into_into_dart().into_dart(),
5778 self.0.network.into_into_dart().into_dart(),
5779 self.0.payee_pubkey.into_into_dart().into_dart(),
5780 self.0.payment_hash.into_into_dart().into_dart(),
5781 self.0.description.into_into_dart().into_dart(),
5782 self.0.description_hash.into_into_dart().into_dart(),
5783 self.0.amount_msat.into_into_dart().into_dart(),
5784 self.0.timestamp.into_into_dart().into_dart(),
5785 self.0.expiry.into_into_dart().into_dart(),
5786 self.0.routing_hints.into_into_dart().into_dart(),
5787 self.0.payment_secret.into_into_dart().into_dart(),
5788 self.0
5789 .min_final_cltv_expiry_delta
5790 .into_into_dart()
5791 .into_dart(),
5792 ]
5793 .into_dart()
5794 }
5795}
5796impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5797 for FrbWrapper<crate::bindings::LNInvoice>
5798{
5799}
5800impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNInvoice>>
5801 for crate::bindings::LNInvoice
5802{
5803 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNInvoice> {
5804 self.into()
5805 }
5806}
5807impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNOffer> {
5809 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5810 [
5811 self.0.offer.into_into_dart().into_dart(),
5812 self.0.chains.into_into_dart().into_dart(),
5813 self.0.min_amount.into_into_dart().into_dart(),
5814 self.0.description.into_into_dart().into_dart(),
5815 self.0.absolute_expiry.into_into_dart().into_dart(),
5816 self.0.issuer.into_into_dart().into_dart(),
5817 self.0.signing_pubkey.into_into_dart().into_dart(),
5818 self.0.paths.into_into_dart().into_dart(),
5819 ]
5820 .into_dart()
5821 }
5822}
5823impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5824 for FrbWrapper<crate::bindings::LNOffer>
5825{
5826}
5827impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNOffer>>
5828 for crate::bindings::LNOffer
5829{
5830 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNOffer> {
5831 self.into()
5832 }
5833}
5834impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5836 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5837 [self.0.blinded_hops.into_into_dart().into_dart()].into_dart()
5838 }
5839}
5840impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5841 for FrbWrapper<crate::bindings::LnOfferBlindedPath>
5842{
5843}
5844impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnOfferBlindedPath>>
5845 for crate::bindings::LnOfferBlindedPath
5846{
5847 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5848 self.into()
5849 }
5850}
5851impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlAuthError {
5853 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5854 match self {
5855 crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
5856 [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
5857 }
5858 crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
5859 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5860 }
5861 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
5862 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5863 }
5864 _ => {
5865 unimplemented!("");
5866 }
5867 }
5868 }
5869}
5870impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5871 for crate::bindings::duplicates::LnUrlAuthError
5872{
5873}
5874impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlAuthError>
5875 for crate::bindings::duplicates::LnUrlAuthError
5876{
5877 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlAuthError {
5878 self
5879 }
5880}
5881impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5883 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5884 [
5885 self.0.k1.into_into_dart().into_dart(),
5886 self.0.action.into_into_dart().into_dart(),
5887 self.0.domain.into_into_dart().into_dart(),
5888 self.0.url.into_into_dart().into_dart(),
5889 ]
5890 .into_dart()
5891 }
5892}
5893impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5894 for FrbWrapper<crate::bindings::LnUrlAuthRequestData>
5895{
5896}
5897impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlAuthRequestData>>
5898 for crate::bindings::LnUrlAuthRequestData
5899{
5900 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5901 self.into()
5902 }
5903}
5904impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlCallbackStatus {
5906 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5907 match self {
5908 crate::bindings::duplicates::LnUrlCallbackStatus::Ok => [0.into_dart()].into_dart(),
5909 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
5910 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
5911 }
5912 _ => {
5913 unimplemented!("");
5914 }
5915 }
5916 }
5917}
5918impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5919 for crate::bindings::duplicates::LnUrlCallbackStatus
5920{
5921}
5922impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlCallbackStatus>
5923 for crate::bindings::duplicates::LnUrlCallbackStatus
5924{
5925 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
5926 self
5927 }
5928}
5929impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlErrorData> {
5931 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5932 [self.0.reason.into_into_dart().into_dart()].into_dart()
5933 }
5934}
5935impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5936 for FrbWrapper<crate::bindings::LnUrlErrorData>
5937{
5938}
5939impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlErrorData>>
5940 for crate::bindings::LnUrlErrorData
5941{
5942 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlErrorData> {
5943 self.into()
5944 }
5945}
5946impl flutter_rust_bridge::IntoDart for crate::model::LnUrlInfo {
5948 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5949 [
5950 self.ln_address.into_into_dart().into_dart(),
5951 self.lnurl_pay_comment.into_into_dart().into_dart(),
5952 self.lnurl_pay_domain.into_into_dart().into_dart(),
5953 self.lnurl_pay_metadata.into_into_dart().into_dart(),
5954 self.lnurl_pay_success_action.into_into_dart().into_dart(),
5955 self.lnurl_pay_unprocessed_success_action
5956 .into_into_dart()
5957 .into_dart(),
5958 self.lnurl_withdraw_endpoint.into_into_dart().into_dart(),
5959 ]
5960 .into_dart()
5961 }
5962}
5963impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlInfo {}
5964impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlInfo> for crate::model::LnUrlInfo {
5965 fn into_into_dart(self) -> crate::model::LnUrlInfo {
5966 self
5967 }
5968}
5969impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlPayError {
5971 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5972 match self {
5973 crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => [0.into_dart()].into_dart(),
5974 crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
5975 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5976 }
5977 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
5978 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5979 }
5980 crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
5981 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
5982 }
5983 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
5984 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
5985 }
5986 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
5987 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
5988 }
5989 crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
5990 [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
5991 }
5992 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
5993 [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
5994 }
5995 crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
5996 [8.into_dart(), err.into_into_dart().into_dart()].into_dart()
5997 }
5998 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
5999 [9.into_dart(), err.into_into_dart().into_dart()].into_dart()
6000 }
6001 crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
6002 [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6003 }
6004 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
6005 [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6006 }
6007 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
6008 [12.into_dart(), err.into_into_dart().into_dart()].into_dart()
6009 }
6010 _ => {
6011 unimplemented!("");
6012 }
6013 }
6014 }
6015}
6016impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6017 for crate::bindings::duplicates::LnUrlPayError
6018{
6019}
6020impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlPayError>
6021 for crate::bindings::duplicates::LnUrlPayError
6022{
6023 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlPayError {
6024 self
6025 }
6026}
6027impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6029 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6030 [
6031 self.0.payment_hash.into_into_dart().into_dart(),
6032 self.0.reason.into_into_dart().into_dart(),
6033 ]
6034 .into_dart()
6035 }
6036}
6037impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6038 for FrbWrapper<crate::bindings::LnUrlPayErrorData>
6039{
6040}
6041impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayErrorData>>
6042 for crate::bindings::LnUrlPayErrorData
6043{
6044 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6045 self.into()
6046 }
6047}
6048impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayRequest {
6050 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6051 [self.prepare_response.into_into_dart().into_dart()].into_dart()
6052 }
6053}
6054impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayRequest {}
6055impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayRequest>
6056 for crate::model::LnUrlPayRequest
6057{
6058 fn into_into_dart(self) -> crate::model::LnUrlPayRequest {
6059 self
6060 }
6061}
6062impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6064 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6065 [
6066 self.0.callback.into_into_dart().into_dart(),
6067 self.0.min_sendable.into_into_dart().into_dart(),
6068 self.0.max_sendable.into_into_dart().into_dart(),
6069 self.0.metadata_str.into_into_dart().into_dart(),
6070 self.0.comment_allowed.into_into_dart().into_dart(),
6071 self.0.domain.into_into_dart().into_dart(),
6072 self.0.allows_nostr.into_into_dart().into_dart(),
6073 self.0.nostr_pubkey.into_into_dart().into_dart(),
6074 self.0.ln_address.into_into_dart().into_dart(),
6075 ]
6076 .into_dart()
6077 }
6078}
6079impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6080 for FrbWrapper<crate::bindings::LnUrlPayRequestData>
6081{
6082}
6083impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayRequestData>>
6084 for crate::bindings::LnUrlPayRequestData
6085{
6086 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6087 self.into()
6088 }
6089}
6090impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayResult {
6092 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6093 match self {
6094 crate::model::LnUrlPayResult::EndpointSuccess { data } => {
6095 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6096 }
6097 crate::model::LnUrlPayResult::EndpointError { data } => {
6098 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6099 }
6100 crate::model::LnUrlPayResult::PayError { data } => {
6101 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6102 }
6103 _ => {
6104 unimplemented!("");
6105 }
6106 }
6107 }
6108}
6109impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayResult {}
6110impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayResult>
6111 for crate::model::LnUrlPayResult
6112{
6113 fn into_into_dart(self) -> crate::model::LnUrlPayResult {
6114 self
6115 }
6116}
6117impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPaySuccessData {
6119 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6120 [
6121 self.payment.into_into_dart().into_dart(),
6122 self.success_action.into_into_dart().into_dart(),
6123 ]
6124 .into_dart()
6125 }
6126}
6127impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6128 for crate::model::LnUrlPaySuccessData
6129{
6130}
6131impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPaySuccessData>
6132 for crate::model::LnUrlPaySuccessData
6133{
6134 fn into_into_dart(self) -> crate::model::LnUrlPaySuccessData {
6135 self
6136 }
6137}
6138impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawError {
6140 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6141 match self {
6142 crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
6143 [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
6144 }
6145 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
6146 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
6147 }
6148 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
6149 [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
6150 }
6151 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
6152 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
6153 }
6154 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
6155 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6156 }
6157 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
6158 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6159 }
6160 _ => {
6161 unimplemented!("");
6162 }
6163 }
6164 }
6165}
6166impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6167 for crate::bindings::duplicates::LnUrlWithdrawError
6168{
6169}
6170impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawError>
6171 for crate::bindings::duplicates::LnUrlWithdrawError
6172{
6173 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
6174 self
6175 }
6176}
6177impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6179 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6180 [
6181 self.0.data.into_into_dart().into_dart(),
6182 self.0.amount_msat.into_into_dart().into_dart(),
6183 self.0.description.into_into_dart().into_dart(),
6184 ]
6185 .into_dart()
6186 }
6187}
6188impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6189 for FrbWrapper<crate::bindings::LnUrlWithdrawRequest>
6190{
6191}
6192impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequest>>
6193 for crate::bindings::LnUrlWithdrawRequest
6194{
6195 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6196 self.into()
6197 }
6198}
6199impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6201 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6202 [
6203 self.0.callback.into_into_dart().into_dart(),
6204 self.0.k1.into_into_dart().into_dart(),
6205 self.0.default_description.into_into_dart().into_dart(),
6206 self.0.min_withdrawable.into_into_dart().into_dart(),
6207 self.0.max_withdrawable.into_into_dart().into_dart(),
6208 ]
6209 .into_dart()
6210 }
6211}
6212impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6213 for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>
6214{
6215}
6216impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>>
6217 for crate::bindings::LnUrlWithdrawRequestData
6218{
6219 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6220 self.into()
6221 }
6222}
6223impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawResult {
6225 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6226 match self {
6227 crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
6228 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6229 }
6230 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
6231 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6232 }
6233 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
6234 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6235 }
6236 _ => {
6237 unimplemented!("");
6238 }
6239 }
6240 }
6241}
6242impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6243 for crate::bindings::duplicates::LnUrlWithdrawResult
6244{
6245}
6246impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawResult>
6247 for crate::bindings::duplicates::LnUrlWithdrawResult
6248{
6249 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
6250 self
6251 }
6252}
6253impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6255 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6256 [self.invoice.into_into_dart().into_dart()].into_dart()
6257 }
6258}
6259impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6260 for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6261{
6262}
6263impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
6264 for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6265{
6266 fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6267 self
6268 }
6269}
6270impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocaleOverrides> {
6272 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6273 [
6274 self.0.locale.into_into_dart().into_dart(),
6275 self.0.spacing.into_into_dart().into_dart(),
6276 self.0.symbol.into_into_dart().into_dart(),
6277 ]
6278 .into_dart()
6279 }
6280}
6281impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6282 for FrbWrapper<crate::bindings::LocaleOverrides>
6283{
6284}
6285impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocaleOverrides>>
6286 for crate::bindings::LocaleOverrides
6287{
6288 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocaleOverrides> {
6289 self.into()
6290 }
6291}
6292impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocalizedName> {
6294 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6295 [
6296 self.0.locale.into_into_dart().into_dart(),
6297 self.0.name.into_into_dart().into_dart(),
6298 ]
6299 .into_dart()
6300 }
6301}
6302impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6303 for FrbWrapper<crate::bindings::LocalizedName>
6304{
6305}
6306impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocalizedName>>
6307 for crate::bindings::LocalizedName
6308{
6309 fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocalizedName> {
6310 self.into()
6311 }
6312}
6313impl flutter_rust_bridge::IntoDart for crate::model::LogEntry {
6315 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6316 [
6317 self.line.into_into_dart().into_dart(),
6318 self.level.into_into_dart().into_dart(),
6319 ]
6320 .into_dart()
6321 }
6322}
6323impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LogEntry {}
6324impl flutter_rust_bridge::IntoIntoDart<crate::model::LogEntry> for crate::model::LogEntry {
6325 fn into_into_dart(self) -> crate::model::LogEntry {
6326 self
6327 }
6328}
6329impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::MessageSuccessActionData> {
6331 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6332 [self.0.message.into_into_dart().into_dart()].into_dart()
6333 }
6334}
6335impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6336 for FrbWrapper<crate::bindings::MessageSuccessActionData>
6337{
6338}
6339impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::MessageSuccessActionData>>
6340 for crate::bindings::MessageSuccessActionData
6341{
6342 fn into_into_dart(self) -> FrbWrapper<crate::bindings::MessageSuccessActionData> {
6343 self.into()
6344 }
6345}
6346impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Network> {
6348 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6349 match self.0 {
6350 crate::bindings::Network::Bitcoin => 0.into_dart(),
6351 crate::bindings::Network::Testnet => 1.into_dart(),
6352 crate::bindings::Network::Signet => 2.into_dart(),
6353 crate::bindings::Network::Regtest => 3.into_dart(),
6354 _ => unreachable!(),
6355 }
6356 }
6357}
6358impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6359 for FrbWrapper<crate::bindings::Network>
6360{
6361}
6362impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Network>>
6363 for crate::bindings::Network
6364{
6365 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Network> {
6366 self.into()
6367 }
6368}
6369impl flutter_rust_bridge::IntoDart for crate::model::OnchainPaymentLimitsResponse {
6371 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6372 [
6373 self.send.into_into_dart().into_dart(),
6374 self.receive.into_into_dart().into_dart(),
6375 ]
6376 .into_dart()
6377 }
6378}
6379impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6380 for crate::model::OnchainPaymentLimitsResponse
6381{
6382}
6383impl flutter_rust_bridge::IntoIntoDart<crate::model::OnchainPaymentLimitsResponse>
6384 for crate::model::OnchainPaymentLimitsResponse
6385{
6386 fn into_into_dart(self) -> crate::model::OnchainPaymentLimitsResponse {
6387 self
6388 }
6389}
6390impl flutter_rust_bridge::IntoDart for crate::model::PayAmount {
6392 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6393 match self {
6394 crate::model::PayAmount::Bitcoin {
6395 receiver_amount_sat,
6396 } => [
6397 0.into_dart(),
6398 receiver_amount_sat.into_into_dart().into_dart(),
6399 ]
6400 .into_dart(),
6401 crate::model::PayAmount::Asset {
6402 asset_id,
6403 receiver_amount,
6404 estimate_asset_fees,
6405 } => [
6406 1.into_dart(),
6407 asset_id.into_into_dart().into_dart(),
6408 receiver_amount.into_into_dart().into_dart(),
6409 estimate_asset_fees.into_into_dart().into_dart(),
6410 ]
6411 .into_dart(),
6412 crate::model::PayAmount::Drain => [2.into_dart()].into_dart(),
6413 _ => {
6414 unimplemented!("");
6415 }
6416 }
6417 }
6418}
6419impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PayAmount {}
6420impl flutter_rust_bridge::IntoIntoDart<crate::model::PayAmount> for crate::model::PayAmount {
6421 fn into_into_dart(self) -> crate::model::PayAmount {
6422 self
6423 }
6424}
6425impl flutter_rust_bridge::IntoDart for crate::model::PayOnchainRequest {
6427 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6428 [
6429 self.address.into_into_dart().into_dart(),
6430 self.prepare_response.into_into_dart().into_dart(),
6431 ]
6432 .into_dart()
6433 }
6434}
6435impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6436 for crate::model::PayOnchainRequest
6437{
6438}
6439impl flutter_rust_bridge::IntoIntoDart<crate::model::PayOnchainRequest>
6440 for crate::model::PayOnchainRequest
6441{
6442 fn into_into_dart(self) -> crate::model::PayOnchainRequest {
6443 self
6444 }
6445}
6446impl flutter_rust_bridge::IntoDart for crate::model::Payment {
6448 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6449 [
6450 self.destination.into_into_dart().into_dart(),
6451 self.tx_id.into_into_dart().into_dart(),
6452 self.unblinding_data.into_into_dart().into_dart(),
6453 self.timestamp.into_into_dart().into_dart(),
6454 self.amount_sat.into_into_dart().into_dart(),
6455 self.fees_sat.into_into_dart().into_dart(),
6456 self.swapper_fees_sat.into_into_dart().into_dart(),
6457 self.payment_type.into_into_dart().into_dart(),
6458 self.status.into_into_dart().into_dart(),
6459 self.details.into_into_dart().into_dart(),
6460 ]
6461 .into_dart()
6462 }
6463}
6464impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Payment {}
6465impl flutter_rust_bridge::IntoIntoDart<crate::model::Payment> for crate::model::Payment {
6466 fn into_into_dart(self) -> crate::model::Payment {
6467 self
6468 }
6469}
6470impl flutter_rust_bridge::IntoDart for crate::model::PaymentDetails {
6472 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6473 match self {
6474 crate::model::PaymentDetails::Lightning {
6475 swap_id,
6476 description,
6477 liquid_expiration_blockheight,
6478 preimage,
6479 invoice,
6480 bolt12_offer,
6481 payment_hash,
6482 destination_pubkey,
6483 lnurl_info,
6484 bip353_address,
6485 payer_note,
6486 claim_tx_id,
6487 refund_tx_id,
6488 refund_tx_amount_sat,
6489 } => [
6490 0.into_dart(),
6491 swap_id.into_into_dart().into_dart(),
6492 description.into_into_dart().into_dart(),
6493 liquid_expiration_blockheight.into_into_dart().into_dart(),
6494 preimage.into_into_dart().into_dart(),
6495 invoice.into_into_dart().into_dart(),
6496 bolt12_offer.into_into_dart().into_dart(),
6497 payment_hash.into_into_dart().into_dart(),
6498 destination_pubkey.into_into_dart().into_dart(),
6499 lnurl_info.into_into_dart().into_dart(),
6500 bip353_address.into_into_dart().into_dart(),
6501 payer_note.into_into_dart().into_dart(),
6502 claim_tx_id.into_into_dart().into_dart(),
6503 refund_tx_id.into_into_dart().into_dart(),
6504 refund_tx_amount_sat.into_into_dart().into_dart(),
6505 ]
6506 .into_dart(),
6507 crate::model::PaymentDetails::Liquid {
6508 destination,
6509 description,
6510 asset_id,
6511 asset_info,
6512 lnurl_info,
6513 bip353_address,
6514 payer_note,
6515 } => [
6516 1.into_dart(),
6517 destination.into_into_dart().into_dart(),
6518 description.into_into_dart().into_dart(),
6519 asset_id.into_into_dart().into_dart(),
6520 asset_info.into_into_dart().into_dart(),
6521 lnurl_info.into_into_dart().into_dart(),
6522 bip353_address.into_into_dart().into_dart(),
6523 payer_note.into_into_dart().into_dart(),
6524 ]
6525 .into_dart(),
6526 crate::model::PaymentDetails::Bitcoin {
6527 swap_id,
6528 bitcoin_address,
6529 description,
6530 auto_accepted_fees,
6531 liquid_expiration_blockheight,
6532 bitcoin_expiration_blockheight,
6533 lockup_tx_id,
6534 claim_tx_id,
6535 refund_tx_id,
6536 refund_tx_amount_sat,
6537 } => [
6538 2.into_dart(),
6539 swap_id.into_into_dart().into_dart(),
6540 bitcoin_address.into_into_dart().into_dart(),
6541 description.into_into_dart().into_dart(),
6542 auto_accepted_fees.into_into_dart().into_dart(),
6543 liquid_expiration_blockheight.into_into_dart().into_dart(),
6544 bitcoin_expiration_blockheight.into_into_dart().into_dart(),
6545 lockup_tx_id.into_into_dart().into_dart(),
6546 claim_tx_id.into_into_dart().into_dart(),
6547 refund_tx_id.into_into_dart().into_dart(),
6548 refund_tx_amount_sat.into_into_dart().into_dart(),
6549 ]
6550 .into_dart(),
6551 _ => {
6552 unimplemented!("");
6553 }
6554 }
6555 }
6556}
6557impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentDetails {}
6558impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentDetails>
6559 for crate::model::PaymentDetails
6560{
6561 fn into_into_dart(self) -> crate::model::PaymentDetails {
6562 self
6563 }
6564}
6565impl flutter_rust_bridge::IntoDart for crate::error::PaymentError {
6567 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6568 match self {
6569 crate::error::PaymentError::AlreadyClaimed => [0.into_dart()].into_dart(),
6570 crate::error::PaymentError::AlreadyPaid => [1.into_dart()].into_dart(),
6571 crate::error::PaymentError::PaymentInProgress => [2.into_dart()].into_dart(),
6572 crate::error::PaymentError::AmountOutOfRange { min, max } => [
6573 3.into_dart(),
6574 min.into_into_dart().into_dart(),
6575 max.into_into_dart().into_dart(),
6576 ]
6577 .into_dart(),
6578 crate::error::PaymentError::AmountMissing { err } => {
6579 [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6580 }
6581 crate::error::PaymentError::AssetError { err } => {
6582 [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6583 }
6584 crate::error::PaymentError::InvalidNetwork { err } => {
6585 [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
6586 }
6587 crate::error::PaymentError::Generic { err } => {
6588 [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
6589 }
6590 crate::error::PaymentError::InvalidOrExpiredFees => [8.into_dart()].into_dart(),
6591 crate::error::PaymentError::InsufficientFunds => [9.into_dart()].into_dart(),
6592 crate::error::PaymentError::InvalidDescription { err } => {
6593 [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6594 }
6595 crate::error::PaymentError::InvalidInvoice { err } => {
6596 [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6597 }
6598 crate::error::PaymentError::InvalidPreimage => [12.into_dart()].into_dart(),
6599 crate::error::PaymentError::PairsNotFound => [13.into_dart()].into_dart(),
6600 crate::error::PaymentError::PaymentTimeout => [14.into_dart()].into_dart(),
6601 crate::error::PaymentError::PersistError => [15.into_dart()].into_dart(),
6602 crate::error::PaymentError::ReceiveError { err } => {
6603 [16.into_dart(), err.into_into_dart().into_dart()].into_dart()
6604 }
6605 crate::error::PaymentError::Refunded { err, refund_tx_id } => [
6606 17.into_dart(),
6607 err.into_into_dart().into_dart(),
6608 refund_tx_id.into_into_dart().into_dart(),
6609 ]
6610 .into_dart(),
6611 crate::error::PaymentError::SelfTransferNotSupported => [18.into_dart()].into_dart(),
6612 crate::error::PaymentError::SendError { err } => {
6613 [19.into_dart(), err.into_into_dart().into_dart()].into_dart()
6614 }
6615 crate::error::PaymentError::SignerError { err } => {
6616 [20.into_dart(), err.into_into_dart().into_dart()].into_dart()
6617 }
6618 _ => {
6619 unimplemented!("");
6620 }
6621 }
6622 }
6623}
6624impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::PaymentError {}
6625impl flutter_rust_bridge::IntoIntoDart<crate::error::PaymentError> for crate::error::PaymentError {
6626 fn into_into_dart(self) -> crate::error::PaymentError {
6627 self
6628 }
6629}
6630impl flutter_rust_bridge::IntoDart for crate::model::PaymentMethod {
6632 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6633 match self {
6634 Self::Lightning => 0.into_dart(),
6635 Self::Bolt11Invoice => 1.into_dart(),
6636 Self::Bolt12Offer => 2.into_dart(),
6637 Self::BitcoinAddress => 3.into_dart(),
6638 Self::LiquidAddress => 4.into_dart(),
6639 _ => unreachable!(),
6640 }
6641 }
6642}
6643impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentMethod {}
6644impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentMethod>
6645 for crate::model::PaymentMethod
6646{
6647 fn into_into_dart(self) -> crate::model::PaymentMethod {
6648 self
6649 }
6650}
6651impl flutter_rust_bridge::IntoDart for crate::model::PaymentState {
6653 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6654 match self {
6655 Self::Created => 0.into_dart(),
6656 Self::Pending => 1.into_dart(),
6657 Self::Complete => 2.into_dart(),
6658 Self::Failed => 3.into_dart(),
6659 Self::TimedOut => 4.into_dart(),
6660 Self::Refundable => 5.into_dart(),
6661 Self::RefundPending => 6.into_dart(),
6662 Self::WaitingFeeAcceptance => 7.into_dart(),
6663 _ => unreachable!(),
6664 }
6665 }
6666}
6667impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentState {}
6668impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentState> for crate::model::PaymentState {
6669 fn into_into_dart(self) -> crate::model::PaymentState {
6670 self
6671 }
6672}
6673impl flutter_rust_bridge::IntoDart for crate::model::PaymentType {
6675 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6676 match self {
6677 Self::Receive => 0.into_dart(),
6678 Self::Send => 1.into_dart(),
6679 _ => unreachable!(),
6680 }
6681 }
6682}
6683impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentType {}
6684impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentType> for crate::model::PaymentType {
6685 fn into_into_dart(self) -> crate::model::PaymentType {
6686 self
6687 }
6688}
6689impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinRequest {
6691 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6692 [
6693 self.provider.into_into_dart().into_dart(),
6694 self.amount_sat.into_into_dart().into_dart(),
6695 ]
6696 .into_dart()
6697 }
6698}
6699impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6700 for crate::model::PrepareBuyBitcoinRequest
6701{
6702}
6703impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinRequest>
6704 for crate::model::PrepareBuyBitcoinRequest
6705{
6706 fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinRequest {
6707 self
6708 }
6709}
6710impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinResponse {
6712 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6713 [
6714 self.provider.into_into_dart().into_dart(),
6715 self.amount_sat.into_into_dart().into_dart(),
6716 self.fees_sat.into_into_dart().into_dart(),
6717 ]
6718 .into_dart()
6719 }
6720}
6721impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6722 for crate::model::PrepareBuyBitcoinResponse
6723{
6724}
6725impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinResponse>
6726 for crate::model::PrepareBuyBitcoinResponse
6727{
6728 fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinResponse {
6729 self
6730 }
6731}
6732impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayRequest {
6734 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6735 [
6736 self.data.into_into_dart().into_dart(),
6737 self.amount.into_into_dart().into_dart(),
6738 self.bip353_address.into_into_dart().into_dart(),
6739 self.comment.into_into_dart().into_dart(),
6740 self.validate_success_action_url
6741 .into_into_dart()
6742 .into_dart(),
6743 ]
6744 .into_dart()
6745 }
6746}
6747impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6748 for crate::model::PrepareLnUrlPayRequest
6749{
6750}
6751impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayRequest>
6752 for crate::model::PrepareLnUrlPayRequest
6753{
6754 fn into_into_dart(self) -> crate::model::PrepareLnUrlPayRequest {
6755 self
6756 }
6757}
6758impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayResponse {
6760 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6761 [
6762 self.destination.into_into_dart().into_dart(),
6763 self.fees_sat.into_into_dart().into_dart(),
6764 self.data.into_into_dart().into_dart(),
6765 self.amount.into_into_dart().into_dart(),
6766 self.comment.into_into_dart().into_dart(),
6767 self.success_action.into_into_dart().into_dart(),
6768 ]
6769 .into_dart()
6770 }
6771}
6772impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6773 for crate::model::PrepareLnUrlPayResponse
6774{
6775}
6776impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayResponse>
6777 for crate::model::PrepareLnUrlPayResponse
6778{
6779 fn into_into_dart(self) -> crate::model::PrepareLnUrlPayResponse {
6780 self
6781 }
6782}
6783impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainRequest {
6785 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6786 [
6787 self.amount.into_into_dart().into_dart(),
6788 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6789 ]
6790 .into_dart()
6791 }
6792}
6793impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6794 for crate::model::PreparePayOnchainRequest
6795{
6796}
6797impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainRequest>
6798 for crate::model::PreparePayOnchainRequest
6799{
6800 fn into_into_dart(self) -> crate::model::PreparePayOnchainRequest {
6801 self
6802 }
6803}
6804impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainResponse {
6806 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6807 [
6808 self.receiver_amount_sat.into_into_dart().into_dart(),
6809 self.claim_fees_sat.into_into_dart().into_dart(),
6810 self.total_fees_sat.into_into_dart().into_dart(),
6811 ]
6812 .into_dart()
6813 }
6814}
6815impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6816 for crate::model::PreparePayOnchainResponse
6817{
6818}
6819impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainResponse>
6820 for crate::model::PreparePayOnchainResponse
6821{
6822 fn into_into_dart(self) -> crate::model::PreparePayOnchainResponse {
6823 self
6824 }
6825}
6826impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveRequest {
6828 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6829 [
6830 self.payment_method.into_into_dart().into_dart(),
6831 self.amount.into_into_dart().into_dart(),
6832 ]
6833 .into_dart()
6834 }
6835}
6836impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6837 for crate::model::PrepareReceiveRequest
6838{
6839}
6840impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveRequest>
6841 for crate::model::PrepareReceiveRequest
6842{
6843 fn into_into_dart(self) -> crate::model::PrepareReceiveRequest {
6844 self
6845 }
6846}
6847impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveResponse {
6849 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6850 [
6851 self.payment_method.into_into_dart().into_dart(),
6852 self.fees_sat.into_into_dart().into_dart(),
6853 self.amount.into_into_dart().into_dart(),
6854 self.min_payer_amount_sat.into_into_dart().into_dart(),
6855 self.max_payer_amount_sat.into_into_dart().into_dart(),
6856 self.swapper_feerate.into_into_dart().into_dart(),
6857 ]
6858 .into_dart()
6859 }
6860}
6861impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6862 for crate::model::PrepareReceiveResponse
6863{
6864}
6865impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveResponse>
6866 for crate::model::PrepareReceiveResponse
6867{
6868 fn into_into_dart(self) -> crate::model::PrepareReceiveResponse {
6869 self
6870 }
6871}
6872impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundRequest {
6874 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6875 [
6876 self.swap_address.into_into_dart().into_dart(),
6877 self.refund_address.into_into_dart().into_dart(),
6878 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6879 ]
6880 .into_dart()
6881 }
6882}
6883impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6884 for crate::model::PrepareRefundRequest
6885{
6886}
6887impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundRequest>
6888 for crate::model::PrepareRefundRequest
6889{
6890 fn into_into_dart(self) -> crate::model::PrepareRefundRequest {
6891 self
6892 }
6893}
6894impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundResponse {
6896 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6897 [
6898 self.tx_vsize.into_into_dart().into_dart(),
6899 self.tx_fee_sat.into_into_dart().into_dart(),
6900 self.last_refund_tx_id.into_into_dart().into_dart(),
6901 ]
6902 .into_dart()
6903 }
6904}
6905impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6906 for crate::model::PrepareRefundResponse
6907{
6908}
6909impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundResponse>
6910 for crate::model::PrepareRefundResponse
6911{
6912 fn into_into_dart(self) -> crate::model::PrepareRefundResponse {
6913 self
6914 }
6915}
6916impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendRequest {
6918 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6919 [
6920 self.destination.into_into_dart().into_dart(),
6921 self.amount.into_into_dart().into_dart(),
6922 ]
6923 .into_dart()
6924 }
6925}
6926impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6927 for crate::model::PrepareSendRequest
6928{
6929}
6930impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendRequest>
6931 for crate::model::PrepareSendRequest
6932{
6933 fn into_into_dart(self) -> crate::model::PrepareSendRequest {
6934 self
6935 }
6936}
6937impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendResponse {
6939 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6940 [
6941 self.destination.into_into_dart().into_dart(),
6942 self.amount.into_into_dart().into_dart(),
6943 self.fees_sat.into_into_dart().into_dart(),
6944 self.estimated_asset_fees.into_into_dart().into_dart(),
6945 ]
6946 .into_dart()
6947 }
6948}
6949impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6950 for crate::model::PrepareSendResponse
6951{
6952}
6953impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendResponse>
6954 for crate::model::PrepareSendResponse
6955{
6956 fn into_into_dart(self) -> crate::model::PrepareSendResponse {
6957 self
6958 }
6959}
6960impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Rate> {
6962 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6963 [
6964 self.0.coin.into_into_dart().into_dart(),
6965 self.0.value.into_into_dart().into_dart(),
6966 ]
6967 .into_dart()
6968 }
6969}
6970impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6971 for FrbWrapper<crate::bindings::Rate>
6972{
6973}
6974impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Rate>>
6975 for crate::bindings::Rate
6976{
6977 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Rate> {
6978 self.into()
6979 }
6980}
6981impl flutter_rust_bridge::IntoDart for crate::model::ReceiveAmount {
6983 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6984 match self {
6985 crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
6986 [0.into_dart(), payer_amount_sat.into_into_dart().into_dart()].into_dart()
6987 }
6988 crate::model::ReceiveAmount::Asset {
6989 asset_id,
6990 payer_amount,
6991 } => [
6992 1.into_dart(),
6993 asset_id.into_into_dart().into_dart(),
6994 payer_amount.into_into_dart().into_dart(),
6995 ]
6996 .into_dart(),
6997 _ => {
6998 unimplemented!("");
6999 }
7000 }
7001 }
7002}
7003impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ReceiveAmount {}
7004impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceiveAmount>
7005 for crate::model::ReceiveAmount
7006{
7007 fn into_into_dart(self) -> crate::model::ReceiveAmount {
7008 self
7009 }
7010}
7011impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentRequest {
7013 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7014 [
7015 self.prepare_response.into_into_dart().into_dart(),
7016 self.description.into_into_dart().into_dart(),
7017 self.use_description_hash.into_into_dart().into_dart(),
7018 self.payer_note.into_into_dart().into_dart(),
7019 ]
7020 .into_dart()
7021 }
7022}
7023impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7024 for crate::model::ReceivePaymentRequest
7025{
7026}
7027impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentRequest>
7028 for crate::model::ReceivePaymentRequest
7029{
7030 fn into_into_dart(self) -> crate::model::ReceivePaymentRequest {
7031 self
7032 }
7033}
7034impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentResponse {
7036 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7037 [self.destination.into_into_dart().into_dart()].into_dart()
7038 }
7039}
7040impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7041 for crate::model::ReceivePaymentResponse
7042{
7043}
7044impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentResponse>
7045 for crate::model::ReceivePaymentResponse
7046{
7047 fn into_into_dart(self) -> crate::model::ReceivePaymentResponse {
7048 self
7049 }
7050}
7051impl flutter_rust_bridge::IntoDart for crate::model::RecommendedFees {
7053 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7054 [
7055 self.fastest_fee.into_into_dart().into_dart(),
7056 self.half_hour_fee.into_into_dart().into_dart(),
7057 self.hour_fee.into_into_dart().into_dart(),
7058 self.economy_fee.into_into_dart().into_dart(),
7059 self.minimum_fee.into_into_dart().into_dart(),
7060 ]
7061 .into_dart()
7062 }
7063}
7064impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RecommendedFees {}
7065impl flutter_rust_bridge::IntoIntoDart<crate::model::RecommendedFees>
7066 for crate::model::RecommendedFees
7067{
7068 fn into_into_dart(self) -> crate::model::RecommendedFees {
7069 self
7070 }
7071}
7072impl flutter_rust_bridge::IntoDart for crate::model::RefundRequest {
7074 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7075 [
7076 self.swap_address.into_into_dart().into_dart(),
7077 self.refund_address.into_into_dart().into_dart(),
7078 self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
7079 ]
7080 .into_dart()
7081 }
7082}
7083impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundRequest {}
7084impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundRequest>
7085 for crate::model::RefundRequest
7086{
7087 fn into_into_dart(self) -> crate::model::RefundRequest {
7088 self
7089 }
7090}
7091impl flutter_rust_bridge::IntoDart for crate::model::RefundResponse {
7093 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7094 [self.refund_tx_id.into_into_dart().into_dart()].into_dart()
7095 }
7096}
7097impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundResponse {}
7098impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundResponse>
7099 for crate::model::RefundResponse
7100{
7101 fn into_into_dart(self) -> crate::model::RefundResponse {
7102 self
7103 }
7104}
7105impl flutter_rust_bridge::IntoDart for crate::model::RefundableSwap {
7107 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7108 [
7109 self.swap_address.into_into_dart().into_dart(),
7110 self.timestamp.into_into_dart().into_dart(),
7111 self.amount_sat.into_into_dart().into_dart(),
7112 self.last_refund_tx_id.into_into_dart().into_dart(),
7113 ]
7114 .into_dart()
7115 }
7116}
7117impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundableSwap {}
7118impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundableSwap>
7119 for crate::model::RefundableSwap
7120{
7121 fn into_into_dart(self) -> crate::model::RefundableSwap {
7122 self
7123 }
7124}
7125impl flutter_rust_bridge::IntoDart for crate::model::RestoreRequest {
7127 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7128 [self.backup_path.into_into_dart().into_dart()].into_dart()
7129 }
7130}
7131impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RestoreRequest {}
7132impl flutter_rust_bridge::IntoIntoDart<crate::model::RestoreRequest>
7133 for crate::model::RestoreRequest
7134{
7135 fn into_into_dart(self) -> crate::model::RestoreRequest {
7136 self
7137 }
7138}
7139impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHint> {
7141 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7142 [self.0.hops.into_into_dart().into_dart()].into_dart()
7143 }
7144}
7145impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7146 for FrbWrapper<crate::bindings::RouteHint>
7147{
7148}
7149impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHint>>
7150 for crate::bindings::RouteHint
7151{
7152 fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHint> {
7153 self.into()
7154 }
7155}
7156impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHintHop> {
7158 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7159 [
7160 self.0.src_node_id.into_into_dart().into_dart(),
7161 self.0.short_channel_id.into_into_dart().into_dart(),
7162 self.0.fees_base_msat.into_into_dart().into_dart(),
7163 self.0
7164 .fees_proportional_millionths
7165 .into_into_dart()
7166 .into_dart(),
7167 self.0.cltv_expiry_delta.into_into_dart().into_dart(),
7168 self.0.htlc_minimum_msat.into_into_dart().into_dart(),
7169 self.0.htlc_maximum_msat.into_into_dart().into_dart(),
7170 ]
7171 .into_dart()
7172 }
7173}
7174impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7175 for FrbWrapper<crate::bindings::RouteHintHop>
7176{
7177}
7178impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHintHop>>
7179 for crate::bindings::RouteHintHop
7180{
7181 fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHintHop> {
7182 self.into()
7183 }
7184}
7185impl flutter_rust_bridge::IntoDart for crate::error::SdkError {
7187 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7188 match self {
7189 crate::error::SdkError::AlreadyStarted => [0.into_dart()].into_dart(),
7190 crate::error::SdkError::Generic { err } => {
7191 [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
7192 }
7193 crate::error::SdkError::NotStarted => [2.into_dart()].into_dart(),
7194 crate::error::SdkError::ServiceConnectivity { err } => {
7195 [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
7196 }
7197 _ => {
7198 unimplemented!("");
7199 }
7200 }
7201 }
7202}
7203impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::SdkError {}
7204impl flutter_rust_bridge::IntoIntoDart<crate::error::SdkError> for crate::error::SdkError {
7205 fn into_into_dart(self) -> crate::error::SdkError {
7206 self
7207 }
7208}
7209impl flutter_rust_bridge::IntoDart for crate::model::SdkEvent {
7211 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7212 match self {
7213 crate::model::SdkEvent::PaymentFailed { details } => {
7214 [0.into_dart(), details.into_into_dart().into_dart()].into_dart()
7215 }
7216 crate::model::SdkEvent::PaymentPending { details } => {
7217 [1.into_dart(), details.into_into_dart().into_dart()].into_dart()
7218 }
7219 crate::model::SdkEvent::PaymentRefundable { details } => {
7220 [2.into_dart(), details.into_into_dart().into_dart()].into_dart()
7221 }
7222 crate::model::SdkEvent::PaymentRefunded { details } => {
7223 [3.into_dart(), details.into_into_dart().into_dart()].into_dart()
7224 }
7225 crate::model::SdkEvent::PaymentRefundPending { details } => {
7226 [4.into_dart(), details.into_into_dart().into_dart()].into_dart()
7227 }
7228 crate::model::SdkEvent::PaymentSucceeded { details } => {
7229 [5.into_dart(), details.into_into_dart().into_dart()].into_dart()
7230 }
7231 crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
7232 [6.into_dart(), details.into_into_dart().into_dart()].into_dart()
7233 }
7234 crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
7235 [7.into_dart(), details.into_into_dart().into_dart()].into_dart()
7236 }
7237 crate::model::SdkEvent::Synced => [8.into_dart()].into_dart(),
7238 crate::model::SdkEvent::DataSynced {
7239 did_pull_new_records,
7240 } => [
7241 9.into_dart(),
7242 did_pull_new_records.into_into_dart().into_dart(),
7243 ]
7244 .into_dart(),
7245 _ => {
7246 unimplemented!("");
7247 }
7248 }
7249 }
7250}
7251impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SdkEvent {}
7252impl flutter_rust_bridge::IntoIntoDart<crate::model::SdkEvent> for crate::model::SdkEvent {
7253 fn into_into_dart(self) -> crate::model::SdkEvent {
7254 self
7255 }
7256}
7257impl flutter_rust_bridge::IntoDart for crate::model::SendDestination {
7259 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7260 match self {
7261 crate::model::SendDestination::LiquidAddress {
7262 address_data,
7263 bip353_address,
7264 } => [
7265 0.into_dart(),
7266 address_data.into_into_dart().into_dart(),
7267 bip353_address.into_into_dart().into_dart(),
7268 ]
7269 .into_dart(),
7270 crate::model::SendDestination::Bolt11 {
7271 invoice,
7272 bip353_address,
7273 } => [
7274 1.into_dart(),
7275 invoice.into_into_dart().into_dart(),
7276 bip353_address.into_into_dart().into_dart(),
7277 ]
7278 .into_dart(),
7279 crate::model::SendDestination::Bolt12 {
7280 offer,
7281 receiver_amount_sat,
7282 bip353_address,
7283 } => [
7284 2.into_dart(),
7285 offer.into_into_dart().into_dart(),
7286 receiver_amount_sat.into_into_dart().into_dart(),
7287 bip353_address.into_into_dart().into_dart(),
7288 ]
7289 .into_dart(),
7290 _ => {
7291 unimplemented!("");
7292 }
7293 }
7294 }
7295}
7296impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SendDestination {}
7297impl flutter_rust_bridge::IntoIntoDart<crate::model::SendDestination>
7298 for crate::model::SendDestination
7299{
7300 fn into_into_dart(self) -> crate::model::SendDestination {
7301 self
7302 }
7303}
7304impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentRequest {
7306 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7307 [
7308 self.prepare_response.into_into_dart().into_dart(),
7309 self.use_asset_fees.into_into_dart().into_dart(),
7310 self.payer_note.into_into_dart().into_dart(),
7311 ]
7312 .into_dart()
7313 }
7314}
7315impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7316 for crate::model::SendPaymentRequest
7317{
7318}
7319impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentRequest>
7320 for crate::model::SendPaymentRequest
7321{
7322 fn into_into_dart(self) -> crate::model::SendPaymentRequest {
7323 self
7324 }
7325}
7326impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentResponse {
7328 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7329 [self.payment.into_into_dart().into_dart()].into_dart()
7330 }
7331}
7332impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7333 for crate::model::SendPaymentResponse
7334{
7335}
7336impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentResponse>
7337 for crate::model::SendPaymentResponse
7338{
7339 fn into_into_dart(self) -> crate::model::SendPaymentResponse {
7340 self
7341 }
7342}
7343impl flutter_rust_bridge::IntoDart for crate::model::SignMessageRequest {
7345 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7346 [self.message.into_into_dart().into_dart()].into_dart()
7347 }
7348}
7349impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7350 for crate::model::SignMessageRequest
7351{
7352}
7353impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageRequest>
7354 for crate::model::SignMessageRequest
7355{
7356 fn into_into_dart(self) -> crate::model::SignMessageRequest {
7357 self
7358 }
7359}
7360impl flutter_rust_bridge::IntoDart for crate::model::SignMessageResponse {
7362 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7363 [self.signature.into_into_dart().into_dart()].into_dart()
7364 }
7365}
7366impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7367 for crate::model::SignMessageResponse
7368{
7369}
7370impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageResponse>
7371 for crate::model::SignMessageResponse
7372{
7373 fn into_into_dart(self) -> crate::model::SignMessageResponse {
7374 self
7375 }
7376}
7377impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessAction> {
7379 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7380 match self.0 {
7381 crate::bindings::SuccessAction::Aes { data } => {
7382 [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
7383 }
7384 crate::bindings::SuccessAction::Message { data } => {
7385 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7386 }
7387 crate::bindings::SuccessAction::Url { data } => {
7388 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7389 }
7390 _ => {
7391 unimplemented!("");
7392 }
7393 }
7394 }
7395}
7396impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7397 for FrbWrapper<crate::bindings::SuccessAction>
7398{
7399}
7400impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessAction>>
7401 for crate::bindings::SuccessAction
7402{
7403 fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessAction> {
7404 self.into()
7405 }
7406}
7407impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessActionProcessed> {
7409 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7410 match self.0 {
7411 crate::bindings::SuccessActionProcessed::Aes { result } => {
7412 [0.into_dart(), result.into_into_dart().into_dart()].into_dart()
7413 }
7414 crate::bindings::SuccessActionProcessed::Message { data } => {
7415 [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7416 }
7417 crate::bindings::SuccessActionProcessed::Url { data } => {
7418 [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7419 }
7420 _ => {
7421 unimplemented!("");
7422 }
7423 }
7424 }
7425}
7426impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7427 for FrbWrapper<crate::bindings::SuccessActionProcessed>
7428{
7429}
7430impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessActionProcessed>>
7431 for crate::bindings::SuccessActionProcessed
7432{
7433 fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessActionProcessed> {
7434 self.into()
7435 }
7436}
7437impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Symbol> {
7439 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7440 [
7441 self.0.grapheme.into_into_dart().into_dart(),
7442 self.0.template.into_into_dart().into_dart(),
7443 self.0.rtl.into_into_dart().into_dart(),
7444 self.0.position.into_into_dart().into_dart(),
7445 ]
7446 .into_dart()
7447 }
7448}
7449impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7450 for FrbWrapper<crate::bindings::Symbol>
7451{
7452}
7453impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Symbol>>
7454 for crate::bindings::Symbol
7455{
7456 fn into_into_dart(self) -> FrbWrapper<crate::bindings::Symbol> {
7457 self.into()
7458 }
7459}
7460impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::UrlSuccessActionData> {
7462 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7463 [
7464 self.0.description.into_into_dart().into_dart(),
7465 self.0.url.into_into_dart().into_dart(),
7466 self.0.matches_callback_domain.into_into_dart().into_dart(),
7467 ]
7468 .into_dart()
7469 }
7470}
7471impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7472 for FrbWrapper<crate::bindings::UrlSuccessActionData>
7473{
7474}
7475impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::UrlSuccessActionData>>
7476 for crate::bindings::UrlSuccessActionData
7477{
7478 fn into_into_dart(self) -> FrbWrapper<crate::bindings::UrlSuccessActionData> {
7479 self.into()
7480 }
7481}
7482impl flutter_rust_bridge::IntoDart for crate::model::WalletInfo {
7484 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7485 [
7486 self.balance_sat.into_into_dart().into_dart(),
7487 self.pending_send_sat.into_into_dart().into_dart(),
7488 self.pending_receive_sat.into_into_dart().into_dart(),
7489 self.fingerprint.into_into_dart().into_dart(),
7490 self.pubkey.into_into_dart().into_dart(),
7491 self.asset_balances.into_into_dart().into_dart(),
7492 ]
7493 .into_dart()
7494 }
7495}
7496impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::WalletInfo {}
7497impl flutter_rust_bridge::IntoIntoDart<crate::model::WalletInfo> for crate::model::WalletInfo {
7498 fn into_into_dart(self) -> crate::model::WalletInfo {
7499 self
7500 }
7501}
7502
7503impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
7504 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7506 <String>::sse_encode(format!("{:?}", self), serializer);
7507 }
7508}
7509
7510impl SseEncode for BindingLiquidSdk {
7511 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7513 <RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer);
7514 }
7515}
7516
7517impl SseEncode
7518 for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
7519{
7520 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7522 let (ptr, size) = self.sse_encode_raw();
7523 <usize>::sse_encode(ptr, serializer);
7524 <i32>::sse_encode(size, serializer);
7525 }
7526}
7527
7528impl SseEncode
7529 for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
7530{
7531 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7533 unimplemented!("")
7534 }
7535}
7536
7537impl SseEncode
7538 for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
7539{
7540 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7542 unimplemented!("")
7543 }
7544}
7545
7546impl SseEncode for String {
7547 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7549 <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
7550 }
7551}
7552
7553impl SseEncode for crate::model::AcceptPaymentProposedFeesRequest {
7554 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7556 <crate::model::FetchPaymentProposedFeesResponse>::sse_encode(self.response, serializer);
7557 }
7558}
7559
7560impl SseEncode for crate::bindings::AesSuccessActionData {
7561 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7563 <String>::sse_encode(self.description, serializer);
7564 <String>::sse_encode(self.ciphertext, serializer);
7565 <String>::sse_encode(self.iv, serializer);
7566 }
7567}
7568
7569impl SseEncode for crate::bindings::AesSuccessActionDataDecrypted {
7570 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7572 <String>::sse_encode(self.description, serializer);
7573 <String>::sse_encode(self.plaintext, serializer);
7574 }
7575}
7576
7577impl SseEncode for crate::bindings::AesSuccessActionDataResult {
7578 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7580 match self {
7581 crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
7582 <i32>::sse_encode(0, serializer);
7583 <crate::bindings::AesSuccessActionDataDecrypted>::sse_encode(data, serializer);
7584 }
7585 crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
7586 <i32>::sse_encode(1, serializer);
7587 <String>::sse_encode(reason, serializer);
7588 }
7589 _ => {
7590 unimplemented!("");
7591 }
7592 }
7593 }
7594}
7595
7596impl SseEncode for crate::bindings::Amount {
7597 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7599 match self {
7600 crate::bindings::Amount::Bitcoin { amount_msat } => {
7601 <i32>::sse_encode(0, serializer);
7602 <u64>::sse_encode(amount_msat, serializer);
7603 }
7604 crate::bindings::Amount::Currency {
7605 iso4217_code,
7606 fractional_amount,
7607 } => {
7608 <i32>::sse_encode(1, serializer);
7609 <String>::sse_encode(iso4217_code, serializer);
7610 <u64>::sse_encode(fractional_amount, serializer);
7611 }
7612 _ => {
7613 unimplemented!("");
7614 }
7615 }
7616 }
7617}
7618
7619impl SseEncode for crate::model::AssetBalance {
7620 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7622 <String>::sse_encode(self.asset_id, serializer);
7623 <u64>::sse_encode(self.balance_sat, serializer);
7624 <Option<String>>::sse_encode(self.name, serializer);
7625 <Option<String>>::sse_encode(self.ticker, serializer);
7626 <Option<f64>>::sse_encode(self.balance, serializer);
7627 }
7628}
7629
7630impl SseEncode for crate::model::AssetInfo {
7631 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7633 <String>::sse_encode(self.name, serializer);
7634 <String>::sse_encode(self.ticker, serializer);
7635 <f64>::sse_encode(self.amount, serializer);
7636 <Option<f64>>::sse_encode(self.fees, serializer);
7637 }
7638}
7639
7640impl SseEncode for crate::model::AssetMetadata {
7641 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7643 <String>::sse_encode(self.asset_id, serializer);
7644 <String>::sse_encode(self.name, serializer);
7645 <String>::sse_encode(self.ticker, serializer);
7646 <u8>::sse_encode(self.precision, serializer);
7647 <Option<String>>::sse_encode(self.fiat_id, serializer);
7648 }
7649}
7650
7651impl SseEncode for crate::model::BackupRequest {
7652 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7654 <Option<String>>::sse_encode(self.backup_path, serializer);
7655 }
7656}
7657
7658impl SseEncode for crate::bindings::BindingEventListener {
7659 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7661 <StreamSink<crate::model::SdkEvent,flutter_rust_bridge::for_generated::DcoCodec>>::sse_encode(self.stream, serializer);
7662 }
7663}
7664
7665impl SseEncode for crate::bindings::BitcoinAddressData {
7666 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7668 <String>::sse_encode(self.address, serializer);
7669 <crate::bindings::Network>::sse_encode(self.network, serializer);
7670 <Option<u64>>::sse_encode(self.amount_sat, serializer);
7671 <Option<String>>::sse_encode(self.label, serializer);
7672 <Option<String>>::sse_encode(self.message, serializer);
7673 }
7674}
7675
7676impl SseEncode for crate::model::BlockchainExplorer {
7677 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7679 match self {
7680 crate::model::BlockchainExplorer::Electrum { url } => {
7681 <i32>::sse_encode(0, serializer);
7682 <String>::sse_encode(url, serializer);
7683 }
7684 crate::model::BlockchainExplorer::Esplora {
7685 url,
7686 use_waterfalls,
7687 } => {
7688 <i32>::sse_encode(1, serializer);
7689 <String>::sse_encode(url, serializer);
7690 <bool>::sse_encode(use_waterfalls, serializer);
7691 }
7692 _ => {
7693 unimplemented!("");
7694 }
7695 }
7696 }
7697}
7698
7699impl SseEncode for crate::model::BlockchainInfo {
7700 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7702 <u32>::sse_encode(self.liquid_tip, serializer);
7703 <u32>::sse_encode(self.bitcoin_tip, serializer);
7704 }
7705}
7706
7707impl SseEncode for bool {
7708 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7710 serializer.cursor.write_u8(self as _).unwrap();
7711 }
7712}
7713
7714impl SseEncode for crate::model::BuyBitcoinProvider {
7715 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7717 <i32>::sse_encode(
7718 match self {
7719 crate::model::BuyBitcoinProvider::Moonpay => 0,
7720 _ => {
7721 unimplemented!("");
7722 }
7723 },
7724 serializer,
7725 );
7726 }
7727}
7728
7729impl SseEncode for crate::model::BuyBitcoinRequest {
7730 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7732 <crate::model::PrepareBuyBitcoinResponse>::sse_encode(self.prepare_response, serializer);
7733 <Option<String>>::sse_encode(self.redirect_url, serializer);
7734 }
7735}
7736
7737impl SseEncode for crate::model::CheckMessageRequest {
7738 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7740 <String>::sse_encode(self.message, serializer);
7741 <String>::sse_encode(self.pubkey, serializer);
7742 <String>::sse_encode(self.signature, serializer);
7743 }
7744}
7745
7746impl SseEncode for crate::model::CheckMessageResponse {
7747 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7749 <bool>::sse_encode(self.is_valid, serializer);
7750 }
7751}
7752
7753impl SseEncode for crate::model::Config {
7754 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7756 <crate::model::BlockchainExplorer>::sse_encode(self.liquid_explorer, serializer);
7757 <crate::model::BlockchainExplorer>::sse_encode(self.bitcoin_explorer, serializer);
7758 <String>::sse_encode(self.working_dir, serializer);
7759 <crate::model::LiquidNetwork>::sse_encode(self.network, serializer);
7760 <u64>::sse_encode(self.payment_timeout_sec, serializer);
7761 <Option<String>>::sse_encode(self.sync_service_url, serializer);
7762 <Option<u64>>::sse_encode(self.zero_conf_max_amount_sat, serializer);
7763 <Option<String>>::sse_encode(self.breez_api_key, serializer);
7764 <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_encode(
7765 self.external_input_parsers,
7766 serializer,
7767 );
7768 <bool>::sse_encode(self.use_default_external_input_parsers, serializer);
7769 <Option<u64>>::sse_encode(self.onchain_fee_rate_leeway_sat, serializer);
7770 <Option<Vec<crate::model::AssetMetadata>>>::sse_encode(self.asset_metadata, serializer);
7771 <Option<String>>::sse_encode(self.sideswap_api_key, serializer);
7772 }
7773}
7774
7775impl SseEncode for crate::model::ConnectRequest {
7776 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7778 <crate::model::Config>::sse_encode(self.config, serializer);
7779 <Option<String>>::sse_encode(self.mnemonic, serializer);
7780 <Option<String>>::sse_encode(self.passphrase, serializer);
7781 <Option<Vec<u8>>>::sse_encode(self.seed, serializer);
7782 }
7783}
7784
7785impl SseEncode for crate::model::CreateBolt12InvoiceRequest {
7786 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7788 <String>::sse_encode(self.offer, serializer);
7789 <String>::sse_encode(self.invoice_request, serializer);
7790 }
7791}
7792
7793impl SseEncode for crate::model::CreateBolt12InvoiceResponse {
7794 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7796 <String>::sse_encode(self.invoice, serializer);
7797 }
7798}
7799
7800impl SseEncode for crate::bindings::CurrencyInfo {
7801 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7803 <String>::sse_encode(self.name, serializer);
7804 <u32>::sse_encode(self.fraction_size, serializer);
7805 <Option<u32>>::sse_encode(self.spacing, serializer);
7806 <Option<crate::bindings::Symbol>>::sse_encode(self.symbol, serializer);
7807 <Option<crate::bindings::Symbol>>::sse_encode(self.uniq_symbol, serializer);
7808 <Vec<crate::bindings::LocalizedName>>::sse_encode(self.localized_name, serializer);
7809 <Vec<crate::bindings::LocaleOverrides>>::sse_encode(self.locale_overrides, serializer);
7810 }
7811}
7812
7813impl SseEncode for crate::bindings::ExternalInputParser {
7814 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7816 <String>::sse_encode(self.provider_id, serializer);
7817 <String>::sse_encode(self.input_regex, serializer);
7818 <String>::sse_encode(self.parser_url, serializer);
7819 }
7820}
7821
7822impl SseEncode for f64 {
7823 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7825 serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
7826 }
7827}
7828
7829impl SseEncode for crate::model::FetchPaymentProposedFeesRequest {
7830 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7832 <String>::sse_encode(self.swap_id, serializer);
7833 }
7834}
7835
7836impl SseEncode for crate::model::FetchPaymentProposedFeesResponse {
7837 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7839 <String>::sse_encode(self.swap_id, serializer);
7840 <u64>::sse_encode(self.fees_sat, serializer);
7841 <u64>::sse_encode(self.payer_amount_sat, serializer);
7842 <u64>::sse_encode(self.receiver_amount_sat, serializer);
7843 }
7844}
7845
7846impl SseEncode for crate::bindings::FiatCurrency {
7847 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7849 <String>::sse_encode(self.id, serializer);
7850 <crate::bindings::CurrencyInfo>::sse_encode(self.info, serializer);
7851 }
7852}
7853
7854impl SseEncode for crate::model::GetInfoResponse {
7855 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7857 <crate::model::WalletInfo>::sse_encode(self.wallet_info, serializer);
7858 <crate::model::BlockchainInfo>::sse_encode(self.blockchain_info, serializer);
7859 }
7860}
7861
7862impl SseEncode for crate::model::GetPaymentRequest {
7863 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7865 match self {
7866 crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
7867 <i32>::sse_encode(0, serializer);
7868 <String>::sse_encode(payment_hash, serializer);
7869 }
7870 crate::model::GetPaymentRequest::SwapId { swap_id } => {
7871 <i32>::sse_encode(1, serializer);
7872 <String>::sse_encode(swap_id, serializer);
7873 }
7874 _ => {
7875 unimplemented!("");
7876 }
7877 }
7878 }
7879}
7880
7881impl SseEncode for i32 {
7882 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7884 serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
7885 }
7886}
7887
7888impl SseEncode for i64 {
7889 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7891 serializer.cursor.write_i64::<NativeEndian>(self).unwrap();
7892 }
7893}
7894
7895impl SseEncode for crate::bindings::InputType {
7896 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7898 match self {
7899 crate::bindings::InputType::BitcoinAddress { address } => {
7900 <i32>::sse_encode(0, serializer);
7901 <crate::bindings::BitcoinAddressData>::sse_encode(address, serializer);
7902 }
7903 crate::bindings::InputType::LiquidAddress { address } => {
7904 <i32>::sse_encode(1, serializer);
7905 <crate::bindings::LiquidAddressData>::sse_encode(address, serializer);
7906 }
7907 crate::bindings::InputType::Bolt11 { invoice } => {
7908 <i32>::sse_encode(2, serializer);
7909 <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
7910 }
7911 crate::bindings::InputType::Bolt12Offer {
7912 offer,
7913 bip353_address,
7914 } => {
7915 <i32>::sse_encode(3, serializer);
7916 <crate::bindings::LNOffer>::sse_encode(offer, serializer);
7917 <Option<String>>::sse_encode(bip353_address, serializer);
7918 }
7919 crate::bindings::InputType::NodeId { node_id } => {
7920 <i32>::sse_encode(4, serializer);
7921 <String>::sse_encode(node_id, serializer);
7922 }
7923 crate::bindings::InputType::Url { url } => {
7924 <i32>::sse_encode(5, serializer);
7925 <String>::sse_encode(url, serializer);
7926 }
7927 crate::bindings::InputType::LnUrlPay {
7928 data,
7929 bip353_address,
7930 } => {
7931 <i32>::sse_encode(6, serializer);
7932 <crate::bindings::LnUrlPayRequestData>::sse_encode(data, serializer);
7933 <Option<String>>::sse_encode(bip353_address, serializer);
7934 }
7935 crate::bindings::InputType::LnUrlWithdraw { data } => {
7936 <i32>::sse_encode(7, serializer);
7937 <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(data, serializer);
7938 }
7939 crate::bindings::InputType::LnUrlAuth { data } => {
7940 <i32>::sse_encode(8, serializer);
7941 <crate::bindings::LnUrlAuthRequestData>::sse_encode(data, serializer);
7942 }
7943 crate::bindings::InputType::LnUrlError { data } => {
7944 <i32>::sse_encode(9, serializer);
7945 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
7946 }
7947 _ => {
7948 unimplemented!("");
7949 }
7950 }
7951 }
7952}
7953
7954impl SseEncode for crate::model::LightningPaymentLimitsResponse {
7955 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7957 <crate::model::Limits>::sse_encode(self.send, serializer);
7958 <crate::model::Limits>::sse_encode(self.receive, serializer);
7959 }
7960}
7961
7962impl SseEncode for crate::model::Limits {
7963 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7965 <u64>::sse_encode(self.min_sat, serializer);
7966 <u64>::sse_encode(self.max_sat, serializer);
7967 <u64>::sse_encode(self.max_zero_conf_sat, serializer);
7968 }
7969}
7970
7971impl SseEncode for crate::bindings::LiquidAddressData {
7972 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7974 <String>::sse_encode(self.address, serializer);
7975 <crate::bindings::Network>::sse_encode(self.network, serializer);
7976 <Option<String>>::sse_encode(self.asset_id, serializer);
7977 <Option<f64>>::sse_encode(self.amount, serializer);
7978 <Option<u64>>::sse_encode(self.amount_sat, serializer);
7979 <Option<String>>::sse_encode(self.label, serializer);
7980 <Option<String>>::sse_encode(self.message, serializer);
7981 }
7982}
7983
7984impl SseEncode for crate::model::LiquidNetwork {
7985 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7987 <i32>::sse_encode(
7988 match self {
7989 crate::model::LiquidNetwork::Mainnet => 0,
7990 crate::model::LiquidNetwork::Testnet => 1,
7991 crate::model::LiquidNetwork::Regtest => 2,
7992 _ => {
7993 unimplemented!("");
7994 }
7995 },
7996 serializer,
7997 );
7998 }
7999}
8000
8001impl SseEncode for Vec<String> {
8002 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8004 <i32>::sse_encode(self.len() as _, serializer);
8005 for item in self {
8006 <String>::sse_encode(item, serializer);
8007 }
8008 }
8009}
8010
8011impl SseEncode for Vec<crate::model::AssetBalance> {
8012 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8014 <i32>::sse_encode(self.len() as _, serializer);
8015 for item in self {
8016 <crate::model::AssetBalance>::sse_encode(item, serializer);
8017 }
8018 }
8019}
8020
8021impl SseEncode for Vec<crate::model::AssetMetadata> {
8022 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8024 <i32>::sse_encode(self.len() as _, serializer);
8025 for item in self {
8026 <crate::model::AssetMetadata>::sse_encode(item, serializer);
8027 }
8028 }
8029}
8030
8031impl SseEncode for Vec<crate::bindings::ExternalInputParser> {
8032 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8034 <i32>::sse_encode(self.len() as _, serializer);
8035 for item in self {
8036 <crate::bindings::ExternalInputParser>::sse_encode(item, serializer);
8037 }
8038 }
8039}
8040
8041impl SseEncode for Vec<crate::bindings::FiatCurrency> {
8042 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8044 <i32>::sse_encode(self.len() as _, serializer);
8045 for item in self {
8046 <crate::bindings::FiatCurrency>::sse_encode(item, serializer);
8047 }
8048 }
8049}
8050
8051impl SseEncode for Vec<crate::bindings::LnOfferBlindedPath> {
8052 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8054 <i32>::sse_encode(self.len() as _, serializer);
8055 for item in self {
8056 <crate::bindings::LnOfferBlindedPath>::sse_encode(item, serializer);
8057 }
8058 }
8059}
8060
8061impl SseEncode for Vec<crate::bindings::LocaleOverrides> {
8062 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8064 <i32>::sse_encode(self.len() as _, serializer);
8065 for item in self {
8066 <crate::bindings::LocaleOverrides>::sse_encode(item, serializer);
8067 }
8068 }
8069}
8070
8071impl SseEncode for Vec<crate::bindings::LocalizedName> {
8072 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8074 <i32>::sse_encode(self.len() as _, serializer);
8075 for item in self {
8076 <crate::bindings::LocalizedName>::sse_encode(item, serializer);
8077 }
8078 }
8079}
8080
8081impl SseEncode for Vec<crate::model::Payment> {
8082 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8084 <i32>::sse_encode(self.len() as _, serializer);
8085 for item in self {
8086 <crate::model::Payment>::sse_encode(item, serializer);
8087 }
8088 }
8089}
8090
8091impl SseEncode for crate::model::ListPaymentDetails {
8092 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8094 match self {
8095 crate::model::ListPaymentDetails::Liquid {
8096 asset_id,
8097 destination,
8098 } => {
8099 <i32>::sse_encode(0, serializer);
8100 <Option<String>>::sse_encode(asset_id, serializer);
8101 <Option<String>>::sse_encode(destination, serializer);
8102 }
8103 crate::model::ListPaymentDetails::Bitcoin { address } => {
8104 <i32>::sse_encode(1, serializer);
8105 <Option<String>>::sse_encode(address, serializer);
8106 }
8107 _ => {
8108 unimplemented!("");
8109 }
8110 }
8111 }
8112}
8113
8114impl SseEncode for Vec<crate::model::PaymentState> {
8115 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8117 <i32>::sse_encode(self.len() as _, serializer);
8118 for item in self {
8119 <crate::model::PaymentState>::sse_encode(item, serializer);
8120 }
8121 }
8122}
8123
8124impl SseEncode for Vec<crate::model::PaymentType> {
8125 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8127 <i32>::sse_encode(self.len() as _, serializer);
8128 for item in self {
8129 <crate::model::PaymentType>::sse_encode(item, serializer);
8130 }
8131 }
8132}
8133
8134impl SseEncode for crate::model::ListPaymentsRequest {
8135 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8137 <Option<Vec<crate::model::PaymentType>>>::sse_encode(self.filters, serializer);
8138 <Option<Vec<crate::model::PaymentState>>>::sse_encode(self.states, serializer);
8139 <Option<i64>>::sse_encode(self.from_timestamp, serializer);
8140 <Option<i64>>::sse_encode(self.to_timestamp, serializer);
8141 <Option<u32>>::sse_encode(self.offset, serializer);
8142 <Option<u32>>::sse_encode(self.limit, serializer);
8143 <Option<crate::model::ListPaymentDetails>>::sse_encode(self.details, serializer);
8144 <Option<bool>>::sse_encode(self.sort_ascending, serializer);
8145 }
8146}
8147
8148impl SseEncode for Vec<u8> {
8149 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8151 <i32>::sse_encode(self.len() as _, serializer);
8152 for item in self {
8153 <u8>::sse_encode(item, serializer);
8154 }
8155 }
8156}
8157
8158impl SseEncode for Vec<crate::bindings::Rate> {
8159 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8161 <i32>::sse_encode(self.len() as _, serializer);
8162 for item in self {
8163 <crate::bindings::Rate>::sse_encode(item, serializer);
8164 }
8165 }
8166}
8167
8168impl SseEncode for Vec<crate::model::RefundableSwap> {
8169 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8171 <i32>::sse_encode(self.len() as _, serializer);
8172 for item in self {
8173 <crate::model::RefundableSwap>::sse_encode(item, serializer);
8174 }
8175 }
8176}
8177
8178impl SseEncode for Vec<crate::bindings::RouteHint> {
8179 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8181 <i32>::sse_encode(self.len() as _, serializer);
8182 for item in self {
8183 <crate::bindings::RouteHint>::sse_encode(item, serializer);
8184 }
8185 }
8186}
8187
8188impl SseEncode for Vec<crate::bindings::RouteHintHop> {
8189 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8191 <i32>::sse_encode(self.len() as _, serializer);
8192 for item in self {
8193 <crate::bindings::RouteHintHop>::sse_encode(item, serializer);
8194 }
8195 }
8196}
8197
8198impl SseEncode for crate::bindings::LNInvoice {
8199 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8201 <String>::sse_encode(self.bolt11, serializer);
8202 <crate::bindings::Network>::sse_encode(self.network, serializer);
8203 <String>::sse_encode(self.payee_pubkey, serializer);
8204 <String>::sse_encode(self.payment_hash, serializer);
8205 <Option<String>>::sse_encode(self.description, serializer);
8206 <Option<String>>::sse_encode(self.description_hash, serializer);
8207 <Option<u64>>::sse_encode(self.amount_msat, serializer);
8208 <u64>::sse_encode(self.timestamp, serializer);
8209 <u64>::sse_encode(self.expiry, serializer);
8210 <Vec<crate::bindings::RouteHint>>::sse_encode(self.routing_hints, serializer);
8211 <Vec<u8>>::sse_encode(self.payment_secret, serializer);
8212 <u64>::sse_encode(self.min_final_cltv_expiry_delta, serializer);
8213 }
8214}
8215
8216impl SseEncode for crate::bindings::LNOffer {
8217 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8219 <String>::sse_encode(self.offer, serializer);
8220 <Vec<String>>::sse_encode(self.chains, serializer);
8221 <Option<crate::bindings::Amount>>::sse_encode(self.min_amount, serializer);
8222 <Option<String>>::sse_encode(self.description, serializer);
8223 <Option<u64>>::sse_encode(self.absolute_expiry, serializer);
8224 <Option<String>>::sse_encode(self.issuer, serializer);
8225 <Option<String>>::sse_encode(self.signing_pubkey, serializer);
8226 <Vec<crate::bindings::LnOfferBlindedPath>>::sse_encode(self.paths, serializer);
8227 }
8228}
8229
8230impl SseEncode for crate::bindings::LnOfferBlindedPath {
8231 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8233 <Vec<String>>::sse_encode(self.blinded_hops, serializer);
8234 }
8235}
8236
8237impl SseEncode for crate::bindings::duplicates::LnUrlAuthError {
8238 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8240 match self {
8241 crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
8242 <i32>::sse_encode(0, serializer);
8243 <String>::sse_encode(err, serializer);
8244 }
8245 crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
8246 <i32>::sse_encode(1, serializer);
8247 <String>::sse_encode(err, serializer);
8248 }
8249 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
8250 <i32>::sse_encode(2, serializer);
8251 <String>::sse_encode(err, serializer);
8252 }
8253 _ => {
8254 unimplemented!("");
8255 }
8256 }
8257 }
8258}
8259
8260impl SseEncode for crate::bindings::LnUrlAuthRequestData {
8261 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8263 <String>::sse_encode(self.k1, serializer);
8264 <Option<String>>::sse_encode(self.action, serializer);
8265 <String>::sse_encode(self.domain, serializer);
8266 <String>::sse_encode(self.url, serializer);
8267 }
8268}
8269
8270impl SseEncode for crate::bindings::duplicates::LnUrlCallbackStatus {
8271 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8273 match self {
8274 crate::bindings::duplicates::LnUrlCallbackStatus::Ok => {
8275 <i32>::sse_encode(0, serializer);
8276 }
8277 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
8278 <i32>::sse_encode(1, serializer);
8279 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8280 }
8281 _ => {
8282 unimplemented!("");
8283 }
8284 }
8285 }
8286}
8287
8288impl SseEncode for crate::bindings::LnUrlErrorData {
8289 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8291 <String>::sse_encode(self.reason, serializer);
8292 }
8293}
8294
8295impl SseEncode for crate::model::LnUrlInfo {
8296 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8298 <Option<String>>::sse_encode(self.ln_address, serializer);
8299 <Option<String>>::sse_encode(self.lnurl_pay_comment, serializer);
8300 <Option<String>>::sse_encode(self.lnurl_pay_domain, serializer);
8301 <Option<String>>::sse_encode(self.lnurl_pay_metadata, serializer);
8302 <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8303 self.lnurl_pay_success_action,
8304 serializer,
8305 );
8306 <Option<crate::bindings::SuccessAction>>::sse_encode(
8307 self.lnurl_pay_unprocessed_success_action,
8308 serializer,
8309 );
8310 <Option<String>>::sse_encode(self.lnurl_withdraw_endpoint, serializer);
8311 }
8312}
8313
8314impl SseEncode for crate::bindings::duplicates::LnUrlPayError {
8315 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8317 match self {
8318 crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => {
8319 <i32>::sse_encode(0, serializer);
8320 }
8321 crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
8322 <i32>::sse_encode(1, serializer);
8323 <String>::sse_encode(err, serializer);
8324 }
8325 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
8326 <i32>::sse_encode(2, serializer);
8327 <String>::sse_encode(err, serializer);
8328 }
8329 crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
8330 <i32>::sse_encode(3, serializer);
8331 <String>::sse_encode(err, serializer);
8332 }
8333 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
8334 <i32>::sse_encode(4, serializer);
8335 <String>::sse_encode(err, serializer);
8336 }
8337 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
8338 <i32>::sse_encode(5, serializer);
8339 <String>::sse_encode(err, serializer);
8340 }
8341 crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
8342 <i32>::sse_encode(6, serializer);
8343 <String>::sse_encode(err, serializer);
8344 }
8345 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
8346 <i32>::sse_encode(7, serializer);
8347 <String>::sse_encode(err, serializer);
8348 }
8349 crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
8350 <i32>::sse_encode(8, serializer);
8351 <String>::sse_encode(err, serializer);
8352 }
8353 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
8354 <i32>::sse_encode(9, serializer);
8355 <String>::sse_encode(err, serializer);
8356 }
8357 crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
8358 <i32>::sse_encode(10, serializer);
8359 <String>::sse_encode(err, serializer);
8360 }
8361 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
8362 <i32>::sse_encode(11, serializer);
8363 <String>::sse_encode(err, serializer);
8364 }
8365 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
8366 <i32>::sse_encode(12, serializer);
8367 <String>::sse_encode(err, serializer);
8368 }
8369 _ => {
8370 unimplemented!("");
8371 }
8372 }
8373 }
8374}
8375
8376impl SseEncode for crate::bindings::LnUrlPayErrorData {
8377 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8379 <String>::sse_encode(self.payment_hash, serializer);
8380 <String>::sse_encode(self.reason, serializer);
8381 }
8382}
8383
8384impl SseEncode for crate::model::LnUrlPayRequest {
8385 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8387 <crate::model::PrepareLnUrlPayResponse>::sse_encode(self.prepare_response, serializer);
8388 }
8389}
8390
8391impl SseEncode for crate::bindings::LnUrlPayRequestData {
8392 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8394 <String>::sse_encode(self.callback, serializer);
8395 <u64>::sse_encode(self.min_sendable, serializer);
8396 <u64>::sse_encode(self.max_sendable, serializer);
8397 <String>::sse_encode(self.metadata_str, serializer);
8398 <u16>::sse_encode(self.comment_allowed, serializer);
8399 <String>::sse_encode(self.domain, serializer);
8400 <bool>::sse_encode(self.allows_nostr, serializer);
8401 <Option<String>>::sse_encode(self.nostr_pubkey, serializer);
8402 <Option<String>>::sse_encode(self.ln_address, serializer);
8403 }
8404}
8405
8406impl SseEncode for crate::model::LnUrlPayResult {
8407 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8409 match self {
8410 crate::model::LnUrlPayResult::EndpointSuccess { data } => {
8411 <i32>::sse_encode(0, serializer);
8412 <crate::model::LnUrlPaySuccessData>::sse_encode(data, serializer);
8413 }
8414 crate::model::LnUrlPayResult::EndpointError { data } => {
8415 <i32>::sse_encode(1, serializer);
8416 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8417 }
8418 crate::model::LnUrlPayResult::PayError { data } => {
8419 <i32>::sse_encode(2, serializer);
8420 <crate::bindings::LnUrlPayErrorData>::sse_encode(data, serializer);
8421 }
8422 _ => {
8423 unimplemented!("");
8424 }
8425 }
8426 }
8427}
8428
8429impl SseEncode for crate::model::LnUrlPaySuccessData {
8430 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8432 <crate::model::Payment>::sse_encode(self.payment, serializer);
8433 <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8434 self.success_action,
8435 serializer,
8436 );
8437 }
8438}
8439
8440impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawError {
8441 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8443 match self {
8444 crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
8445 <i32>::sse_encode(0, serializer);
8446 <String>::sse_encode(err, serializer);
8447 }
8448 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
8449 <i32>::sse_encode(1, serializer);
8450 <String>::sse_encode(err, serializer);
8451 }
8452 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
8453 <i32>::sse_encode(2, serializer);
8454 <String>::sse_encode(err, serializer);
8455 }
8456 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
8457 <i32>::sse_encode(3, serializer);
8458 <String>::sse_encode(err, serializer);
8459 }
8460 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
8461 <i32>::sse_encode(4, serializer);
8462 <String>::sse_encode(err, serializer);
8463 }
8464 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
8465 <i32>::sse_encode(5, serializer);
8466 <String>::sse_encode(err, serializer);
8467 }
8468 _ => {
8469 unimplemented!("");
8470 }
8471 }
8472 }
8473}
8474
8475impl SseEncode for crate::bindings::LnUrlWithdrawRequest {
8476 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8478 <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(self.data, serializer);
8479 <u64>::sse_encode(self.amount_msat, serializer);
8480 <Option<String>>::sse_encode(self.description, serializer);
8481 }
8482}
8483
8484impl SseEncode for crate::bindings::LnUrlWithdrawRequestData {
8485 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8487 <String>::sse_encode(self.callback, serializer);
8488 <String>::sse_encode(self.k1, serializer);
8489 <String>::sse_encode(self.default_description, serializer);
8490 <u64>::sse_encode(self.min_withdrawable, serializer);
8491 <u64>::sse_encode(self.max_withdrawable, serializer);
8492 }
8493}
8494
8495impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawResult {
8496 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8498 match self {
8499 crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
8500 <i32>::sse_encode(0, serializer);
8501 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8502 data, serializer,
8503 );
8504 }
8505 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
8506 <i32>::sse_encode(1, serializer);
8507 <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8508 data, serializer,
8509 );
8510 }
8511 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
8512 <i32>::sse_encode(2, serializer);
8513 <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8514 }
8515 _ => {
8516 unimplemented!("");
8517 }
8518 }
8519 }
8520}
8521
8522impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
8523 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8525 <crate::bindings::LNInvoice>::sse_encode(self.invoice, serializer);
8526 }
8527}
8528
8529impl SseEncode for crate::bindings::LocaleOverrides {
8530 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8532 <String>::sse_encode(self.locale, serializer);
8533 <Option<u32>>::sse_encode(self.spacing, serializer);
8534 <crate::bindings::Symbol>::sse_encode(self.symbol, serializer);
8535 }
8536}
8537
8538impl SseEncode for crate::bindings::LocalizedName {
8539 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8541 <String>::sse_encode(self.locale, serializer);
8542 <String>::sse_encode(self.name, serializer);
8543 }
8544}
8545
8546impl SseEncode for crate::model::LogEntry {
8547 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8549 <String>::sse_encode(self.line, serializer);
8550 <String>::sse_encode(self.level, serializer);
8551 }
8552}
8553
8554impl SseEncode for crate::bindings::MessageSuccessActionData {
8555 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8557 <String>::sse_encode(self.message, serializer);
8558 }
8559}
8560
8561impl SseEncode for crate::bindings::Network {
8562 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8564 <i32>::sse_encode(
8565 match self {
8566 crate::bindings::Network::Bitcoin => 0,
8567 crate::bindings::Network::Testnet => 1,
8568 crate::bindings::Network::Signet => 2,
8569 crate::bindings::Network::Regtest => 3,
8570 _ => {
8571 unimplemented!("");
8572 }
8573 },
8574 serializer,
8575 );
8576 }
8577}
8578
8579impl SseEncode for crate::model::OnchainPaymentLimitsResponse {
8580 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8582 <crate::model::Limits>::sse_encode(self.send, serializer);
8583 <crate::model::Limits>::sse_encode(self.receive, serializer);
8584 }
8585}
8586
8587impl SseEncode for Option<String> {
8588 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8590 <bool>::sse_encode(self.is_some(), serializer);
8591 if let Some(value) = self {
8592 <String>::sse_encode(value, serializer);
8593 }
8594 }
8595}
8596
8597impl SseEncode for Option<crate::bindings::Amount> {
8598 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8600 <bool>::sse_encode(self.is_some(), serializer);
8601 if let Some(value) = self {
8602 <crate::bindings::Amount>::sse_encode(value, serializer);
8603 }
8604 }
8605}
8606
8607impl SseEncode for Option<crate::model::AssetInfo> {
8608 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8610 <bool>::sse_encode(self.is_some(), serializer);
8611 if let Some(value) = self {
8612 <crate::model::AssetInfo>::sse_encode(value, serializer);
8613 }
8614 }
8615}
8616
8617impl SseEncode for Option<bool> {
8618 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8620 <bool>::sse_encode(self.is_some(), serializer);
8621 if let Some(value) = self {
8622 <bool>::sse_encode(value, serializer);
8623 }
8624 }
8625}
8626
8627impl SseEncode for Option<f64> {
8628 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8630 <bool>::sse_encode(self.is_some(), serializer);
8631 if let Some(value) = self {
8632 <f64>::sse_encode(value, serializer);
8633 }
8634 }
8635}
8636
8637impl SseEncode for Option<i64> {
8638 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8640 <bool>::sse_encode(self.is_some(), serializer);
8641 if let Some(value) = self {
8642 <i64>::sse_encode(value, serializer);
8643 }
8644 }
8645}
8646
8647impl SseEncode for Option<crate::model::ListPaymentDetails> {
8648 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8650 <bool>::sse_encode(self.is_some(), serializer);
8651 if let Some(value) = self {
8652 <crate::model::ListPaymentDetails>::sse_encode(value, serializer);
8653 }
8654 }
8655}
8656
8657impl SseEncode for Option<crate::model::LnUrlInfo> {
8658 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8660 <bool>::sse_encode(self.is_some(), serializer);
8661 if let Some(value) = self {
8662 <crate::model::LnUrlInfo>::sse_encode(value, serializer);
8663 }
8664 }
8665}
8666
8667impl SseEncode for Option<crate::model::PayAmount> {
8668 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8670 <bool>::sse_encode(self.is_some(), serializer);
8671 if let Some(value) = self {
8672 <crate::model::PayAmount>::sse_encode(value, serializer);
8673 }
8674 }
8675}
8676
8677impl SseEncode for Option<crate::model::Payment> {
8678 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8680 <bool>::sse_encode(self.is_some(), serializer);
8681 if let Some(value) = self {
8682 <crate::model::Payment>::sse_encode(value, serializer);
8683 }
8684 }
8685}
8686
8687impl SseEncode for Option<crate::model::ReceiveAmount> {
8688 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8690 <bool>::sse_encode(self.is_some(), serializer);
8691 if let Some(value) = self {
8692 <crate::model::ReceiveAmount>::sse_encode(value, serializer);
8693 }
8694 }
8695}
8696
8697impl SseEncode for Option<crate::bindings::SuccessAction> {
8698 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8700 <bool>::sse_encode(self.is_some(), serializer);
8701 if let Some(value) = self {
8702 <crate::bindings::SuccessAction>::sse_encode(value, serializer);
8703 }
8704 }
8705}
8706
8707impl SseEncode for Option<crate::bindings::SuccessActionProcessed> {
8708 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8710 <bool>::sse_encode(self.is_some(), serializer);
8711 if let Some(value) = self {
8712 <crate::bindings::SuccessActionProcessed>::sse_encode(value, serializer);
8713 }
8714 }
8715}
8716
8717impl SseEncode for Option<crate::bindings::Symbol> {
8718 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8720 <bool>::sse_encode(self.is_some(), serializer);
8721 if let Some(value) = self {
8722 <crate::bindings::Symbol>::sse_encode(value, serializer);
8723 }
8724 }
8725}
8726
8727impl SseEncode for Option<u32> {
8728 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8730 <bool>::sse_encode(self.is_some(), serializer);
8731 if let Some(value) = self {
8732 <u32>::sse_encode(value, serializer);
8733 }
8734 }
8735}
8736
8737impl SseEncode for Option<u64> {
8738 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8740 <bool>::sse_encode(self.is_some(), serializer);
8741 if let Some(value) = self {
8742 <u64>::sse_encode(value, serializer);
8743 }
8744 }
8745}
8746
8747impl SseEncode for Option<Vec<crate::model::AssetMetadata>> {
8748 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8750 <bool>::sse_encode(self.is_some(), serializer);
8751 if let Some(value) = self {
8752 <Vec<crate::model::AssetMetadata>>::sse_encode(value, serializer);
8753 }
8754 }
8755}
8756
8757impl SseEncode for Option<Vec<crate::bindings::ExternalInputParser>> {
8758 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8760 <bool>::sse_encode(self.is_some(), serializer);
8761 if let Some(value) = self {
8762 <Vec<crate::bindings::ExternalInputParser>>::sse_encode(value, serializer);
8763 }
8764 }
8765}
8766
8767impl SseEncode for Option<Vec<crate::model::PaymentState>> {
8768 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8770 <bool>::sse_encode(self.is_some(), serializer);
8771 if let Some(value) = self {
8772 <Vec<crate::model::PaymentState>>::sse_encode(value, serializer);
8773 }
8774 }
8775}
8776
8777impl SseEncode for Option<Vec<crate::model::PaymentType>> {
8778 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8780 <bool>::sse_encode(self.is_some(), serializer);
8781 if let Some(value) = self {
8782 <Vec<crate::model::PaymentType>>::sse_encode(value, serializer);
8783 }
8784 }
8785}
8786
8787impl SseEncode for Option<Vec<u8>> {
8788 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8790 <bool>::sse_encode(self.is_some(), serializer);
8791 if let Some(value) = self {
8792 <Vec<u8>>::sse_encode(value, serializer);
8793 }
8794 }
8795}
8796
8797impl SseEncode for crate::model::PayAmount {
8798 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8800 match self {
8801 crate::model::PayAmount::Bitcoin {
8802 receiver_amount_sat,
8803 } => {
8804 <i32>::sse_encode(0, serializer);
8805 <u64>::sse_encode(receiver_amount_sat, serializer);
8806 }
8807 crate::model::PayAmount::Asset {
8808 asset_id,
8809 receiver_amount,
8810 estimate_asset_fees,
8811 } => {
8812 <i32>::sse_encode(1, serializer);
8813 <String>::sse_encode(asset_id, serializer);
8814 <f64>::sse_encode(receiver_amount, serializer);
8815 <Option<bool>>::sse_encode(estimate_asset_fees, serializer);
8816 }
8817 crate::model::PayAmount::Drain => {
8818 <i32>::sse_encode(2, serializer);
8819 }
8820 _ => {
8821 unimplemented!("");
8822 }
8823 }
8824 }
8825}
8826
8827impl SseEncode for crate::model::PayOnchainRequest {
8828 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8830 <String>::sse_encode(self.address, serializer);
8831 <crate::model::PreparePayOnchainResponse>::sse_encode(self.prepare_response, serializer);
8832 }
8833}
8834
8835impl SseEncode for crate::model::Payment {
8836 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8838 <Option<String>>::sse_encode(self.destination, serializer);
8839 <Option<String>>::sse_encode(self.tx_id, serializer);
8840 <Option<String>>::sse_encode(self.unblinding_data, serializer);
8841 <u32>::sse_encode(self.timestamp, serializer);
8842 <u64>::sse_encode(self.amount_sat, serializer);
8843 <u64>::sse_encode(self.fees_sat, serializer);
8844 <Option<u64>>::sse_encode(self.swapper_fees_sat, serializer);
8845 <crate::model::PaymentType>::sse_encode(self.payment_type, serializer);
8846 <crate::model::PaymentState>::sse_encode(self.status, serializer);
8847 <crate::model::PaymentDetails>::sse_encode(self.details, serializer);
8848 }
8849}
8850
8851impl SseEncode for crate::model::PaymentDetails {
8852 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8854 match self {
8855 crate::model::PaymentDetails::Lightning {
8856 swap_id,
8857 description,
8858 liquid_expiration_blockheight,
8859 preimage,
8860 invoice,
8861 bolt12_offer,
8862 payment_hash,
8863 destination_pubkey,
8864 lnurl_info,
8865 bip353_address,
8866 payer_note,
8867 claim_tx_id,
8868 refund_tx_id,
8869 refund_tx_amount_sat,
8870 } => {
8871 <i32>::sse_encode(0, serializer);
8872 <String>::sse_encode(swap_id, serializer);
8873 <String>::sse_encode(description, serializer);
8874 <u32>::sse_encode(liquid_expiration_blockheight, serializer);
8875 <Option<String>>::sse_encode(preimage, serializer);
8876 <Option<String>>::sse_encode(invoice, serializer);
8877 <Option<String>>::sse_encode(bolt12_offer, serializer);
8878 <Option<String>>::sse_encode(payment_hash, serializer);
8879 <Option<String>>::sse_encode(destination_pubkey, serializer);
8880 <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8881 <Option<String>>::sse_encode(bip353_address, serializer);
8882 <Option<String>>::sse_encode(payer_note, serializer);
8883 <Option<String>>::sse_encode(claim_tx_id, serializer);
8884 <Option<String>>::sse_encode(refund_tx_id, serializer);
8885 <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8886 }
8887 crate::model::PaymentDetails::Liquid {
8888 destination,
8889 description,
8890 asset_id,
8891 asset_info,
8892 lnurl_info,
8893 bip353_address,
8894 payer_note,
8895 } => {
8896 <i32>::sse_encode(1, serializer);
8897 <String>::sse_encode(destination, serializer);
8898 <String>::sse_encode(description, serializer);
8899 <String>::sse_encode(asset_id, serializer);
8900 <Option<crate::model::AssetInfo>>::sse_encode(asset_info, serializer);
8901 <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8902 <Option<String>>::sse_encode(bip353_address, serializer);
8903 <Option<String>>::sse_encode(payer_note, serializer);
8904 }
8905 crate::model::PaymentDetails::Bitcoin {
8906 swap_id,
8907 bitcoin_address,
8908 description,
8909 auto_accepted_fees,
8910 liquid_expiration_blockheight,
8911 bitcoin_expiration_blockheight,
8912 lockup_tx_id,
8913 claim_tx_id,
8914 refund_tx_id,
8915 refund_tx_amount_sat,
8916 } => {
8917 <i32>::sse_encode(2, serializer);
8918 <String>::sse_encode(swap_id, serializer);
8919 <String>::sse_encode(bitcoin_address, serializer);
8920 <String>::sse_encode(description, serializer);
8921 <bool>::sse_encode(auto_accepted_fees, serializer);
8922 <Option<u32>>::sse_encode(liquid_expiration_blockheight, serializer);
8923 <Option<u32>>::sse_encode(bitcoin_expiration_blockheight, serializer);
8924 <Option<String>>::sse_encode(lockup_tx_id, serializer);
8925 <Option<String>>::sse_encode(claim_tx_id, serializer);
8926 <Option<String>>::sse_encode(refund_tx_id, serializer);
8927 <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8928 }
8929 _ => {
8930 unimplemented!("");
8931 }
8932 }
8933 }
8934}
8935
8936impl SseEncode for crate::error::PaymentError {
8937 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8939 match self {
8940 crate::error::PaymentError::AlreadyClaimed => {
8941 <i32>::sse_encode(0, serializer);
8942 }
8943 crate::error::PaymentError::AlreadyPaid => {
8944 <i32>::sse_encode(1, serializer);
8945 }
8946 crate::error::PaymentError::PaymentInProgress => {
8947 <i32>::sse_encode(2, serializer);
8948 }
8949 crate::error::PaymentError::AmountOutOfRange { min, max } => {
8950 <i32>::sse_encode(3, serializer);
8951 <u64>::sse_encode(min, serializer);
8952 <u64>::sse_encode(max, serializer);
8953 }
8954 crate::error::PaymentError::AmountMissing { err } => {
8955 <i32>::sse_encode(4, serializer);
8956 <String>::sse_encode(err, serializer);
8957 }
8958 crate::error::PaymentError::AssetError { err } => {
8959 <i32>::sse_encode(5, serializer);
8960 <String>::sse_encode(err, serializer);
8961 }
8962 crate::error::PaymentError::InvalidNetwork { err } => {
8963 <i32>::sse_encode(6, serializer);
8964 <String>::sse_encode(err, serializer);
8965 }
8966 crate::error::PaymentError::Generic { err } => {
8967 <i32>::sse_encode(7, serializer);
8968 <String>::sse_encode(err, serializer);
8969 }
8970 crate::error::PaymentError::InvalidOrExpiredFees => {
8971 <i32>::sse_encode(8, serializer);
8972 }
8973 crate::error::PaymentError::InsufficientFunds => {
8974 <i32>::sse_encode(9, serializer);
8975 }
8976 crate::error::PaymentError::InvalidDescription { err } => {
8977 <i32>::sse_encode(10, serializer);
8978 <String>::sse_encode(err, serializer);
8979 }
8980 crate::error::PaymentError::InvalidInvoice { err } => {
8981 <i32>::sse_encode(11, serializer);
8982 <String>::sse_encode(err, serializer);
8983 }
8984 crate::error::PaymentError::InvalidPreimage => {
8985 <i32>::sse_encode(12, serializer);
8986 }
8987 crate::error::PaymentError::PairsNotFound => {
8988 <i32>::sse_encode(13, serializer);
8989 }
8990 crate::error::PaymentError::PaymentTimeout => {
8991 <i32>::sse_encode(14, serializer);
8992 }
8993 crate::error::PaymentError::PersistError => {
8994 <i32>::sse_encode(15, serializer);
8995 }
8996 crate::error::PaymentError::ReceiveError { err } => {
8997 <i32>::sse_encode(16, serializer);
8998 <String>::sse_encode(err, serializer);
8999 }
9000 crate::error::PaymentError::Refunded { err, refund_tx_id } => {
9001 <i32>::sse_encode(17, serializer);
9002 <String>::sse_encode(err, serializer);
9003 <String>::sse_encode(refund_tx_id, serializer);
9004 }
9005 crate::error::PaymentError::SelfTransferNotSupported => {
9006 <i32>::sse_encode(18, serializer);
9007 }
9008 crate::error::PaymentError::SendError { err } => {
9009 <i32>::sse_encode(19, serializer);
9010 <String>::sse_encode(err, serializer);
9011 }
9012 crate::error::PaymentError::SignerError { err } => {
9013 <i32>::sse_encode(20, serializer);
9014 <String>::sse_encode(err, serializer);
9015 }
9016 _ => {
9017 unimplemented!("");
9018 }
9019 }
9020 }
9021}
9022
9023impl SseEncode for crate::model::PaymentMethod {
9024 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9026 <i32>::sse_encode(
9027 match self {
9028 crate::model::PaymentMethod::Lightning => 0,
9029 crate::model::PaymentMethod::Bolt11Invoice => 1,
9030 crate::model::PaymentMethod::Bolt12Offer => 2,
9031 crate::model::PaymentMethod::BitcoinAddress => 3,
9032 crate::model::PaymentMethod::LiquidAddress => 4,
9033 _ => {
9034 unimplemented!("");
9035 }
9036 },
9037 serializer,
9038 );
9039 }
9040}
9041
9042impl SseEncode for crate::model::PaymentState {
9043 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9045 <i32>::sse_encode(
9046 match self {
9047 crate::model::PaymentState::Created => 0,
9048 crate::model::PaymentState::Pending => 1,
9049 crate::model::PaymentState::Complete => 2,
9050 crate::model::PaymentState::Failed => 3,
9051 crate::model::PaymentState::TimedOut => 4,
9052 crate::model::PaymentState::Refundable => 5,
9053 crate::model::PaymentState::RefundPending => 6,
9054 crate::model::PaymentState::WaitingFeeAcceptance => 7,
9055 _ => {
9056 unimplemented!("");
9057 }
9058 },
9059 serializer,
9060 );
9061 }
9062}
9063
9064impl SseEncode for crate::model::PaymentType {
9065 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9067 <i32>::sse_encode(
9068 match self {
9069 crate::model::PaymentType::Receive => 0,
9070 crate::model::PaymentType::Send => 1,
9071 _ => {
9072 unimplemented!("");
9073 }
9074 },
9075 serializer,
9076 );
9077 }
9078}
9079
9080impl SseEncode for crate::model::PrepareBuyBitcoinRequest {
9081 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9083 <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9084 <u64>::sse_encode(self.amount_sat, serializer);
9085 }
9086}
9087
9088impl SseEncode for crate::model::PrepareBuyBitcoinResponse {
9089 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9091 <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9092 <u64>::sse_encode(self.amount_sat, serializer);
9093 <u64>::sse_encode(self.fees_sat, serializer);
9094 }
9095}
9096
9097impl SseEncode for crate::model::PrepareLnUrlPayRequest {
9098 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9100 <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9101 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9102 <Option<String>>::sse_encode(self.bip353_address, serializer);
9103 <Option<String>>::sse_encode(self.comment, serializer);
9104 <Option<bool>>::sse_encode(self.validate_success_action_url, serializer);
9105 }
9106}
9107
9108impl SseEncode for crate::model::PrepareLnUrlPayResponse {
9109 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9111 <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9112 <u64>::sse_encode(self.fees_sat, serializer);
9113 <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9114 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9115 <Option<String>>::sse_encode(self.comment, serializer);
9116 <Option<crate::bindings::SuccessAction>>::sse_encode(self.success_action, serializer);
9117 }
9118}
9119
9120impl SseEncode for crate::model::PreparePayOnchainRequest {
9121 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9123 <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9124 <Option<u32>>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9125 }
9126}
9127
9128impl SseEncode for crate::model::PreparePayOnchainResponse {
9129 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9131 <u64>::sse_encode(self.receiver_amount_sat, serializer);
9132 <u64>::sse_encode(self.claim_fees_sat, serializer);
9133 <u64>::sse_encode(self.total_fees_sat, serializer);
9134 }
9135}
9136
9137impl SseEncode for crate::model::PrepareReceiveRequest {
9138 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9140 <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9141 <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9142 }
9143}
9144
9145impl SseEncode for crate::model::PrepareReceiveResponse {
9146 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9148 <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9149 <u64>::sse_encode(self.fees_sat, serializer);
9150 <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9151 <Option<u64>>::sse_encode(self.min_payer_amount_sat, serializer);
9152 <Option<u64>>::sse_encode(self.max_payer_amount_sat, serializer);
9153 <Option<f64>>::sse_encode(self.swapper_feerate, serializer);
9154 }
9155}
9156
9157impl SseEncode for crate::model::PrepareRefundRequest {
9158 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9160 <String>::sse_encode(self.swap_address, serializer);
9161 <String>::sse_encode(self.refund_address, serializer);
9162 <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9163 }
9164}
9165
9166impl SseEncode for crate::model::PrepareRefundResponse {
9167 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9169 <u32>::sse_encode(self.tx_vsize, serializer);
9170 <u64>::sse_encode(self.tx_fee_sat, serializer);
9171 <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9172 }
9173}
9174
9175impl SseEncode for crate::model::PrepareSendRequest {
9176 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9178 <String>::sse_encode(self.destination, serializer);
9179 <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9180 }
9181}
9182
9183impl SseEncode for crate::model::PrepareSendResponse {
9184 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9186 <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9187 <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9188 <Option<u64>>::sse_encode(self.fees_sat, serializer);
9189 <Option<f64>>::sse_encode(self.estimated_asset_fees, serializer);
9190 }
9191}
9192
9193impl SseEncode for crate::bindings::Rate {
9194 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9196 <String>::sse_encode(self.coin, serializer);
9197 <f64>::sse_encode(self.value, serializer);
9198 }
9199}
9200
9201impl SseEncode for crate::model::ReceiveAmount {
9202 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9204 match self {
9205 crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
9206 <i32>::sse_encode(0, serializer);
9207 <u64>::sse_encode(payer_amount_sat, serializer);
9208 }
9209 crate::model::ReceiveAmount::Asset {
9210 asset_id,
9211 payer_amount,
9212 } => {
9213 <i32>::sse_encode(1, serializer);
9214 <String>::sse_encode(asset_id, serializer);
9215 <Option<f64>>::sse_encode(payer_amount, serializer);
9216 }
9217 _ => {
9218 unimplemented!("");
9219 }
9220 }
9221 }
9222}
9223
9224impl SseEncode for crate::model::ReceivePaymentRequest {
9225 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9227 <crate::model::PrepareReceiveResponse>::sse_encode(self.prepare_response, serializer);
9228 <Option<String>>::sse_encode(self.description, serializer);
9229 <Option<bool>>::sse_encode(self.use_description_hash, serializer);
9230 <Option<String>>::sse_encode(self.payer_note, serializer);
9231 }
9232}
9233
9234impl SseEncode for crate::model::ReceivePaymentResponse {
9235 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9237 <String>::sse_encode(self.destination, serializer);
9238 }
9239}
9240
9241impl SseEncode for crate::model::RecommendedFees {
9242 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9244 <u64>::sse_encode(self.fastest_fee, serializer);
9245 <u64>::sse_encode(self.half_hour_fee, serializer);
9246 <u64>::sse_encode(self.hour_fee, serializer);
9247 <u64>::sse_encode(self.economy_fee, serializer);
9248 <u64>::sse_encode(self.minimum_fee, serializer);
9249 }
9250}
9251
9252impl SseEncode for crate::model::RefundRequest {
9253 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9255 <String>::sse_encode(self.swap_address, serializer);
9256 <String>::sse_encode(self.refund_address, serializer);
9257 <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9258 }
9259}
9260
9261impl SseEncode for crate::model::RefundResponse {
9262 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9264 <String>::sse_encode(self.refund_tx_id, serializer);
9265 }
9266}
9267
9268impl SseEncode for crate::model::RefundableSwap {
9269 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9271 <String>::sse_encode(self.swap_address, serializer);
9272 <u32>::sse_encode(self.timestamp, serializer);
9273 <u64>::sse_encode(self.amount_sat, serializer);
9274 <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9275 }
9276}
9277
9278impl SseEncode for crate::model::RestoreRequest {
9279 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9281 <Option<String>>::sse_encode(self.backup_path, serializer);
9282 }
9283}
9284
9285impl SseEncode for crate::bindings::RouteHint {
9286 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9288 <Vec<crate::bindings::RouteHintHop>>::sse_encode(self.hops, serializer);
9289 }
9290}
9291
9292impl SseEncode for crate::bindings::RouteHintHop {
9293 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9295 <String>::sse_encode(self.src_node_id, serializer);
9296 <String>::sse_encode(self.short_channel_id, serializer);
9297 <u32>::sse_encode(self.fees_base_msat, serializer);
9298 <u32>::sse_encode(self.fees_proportional_millionths, serializer);
9299 <u64>::sse_encode(self.cltv_expiry_delta, serializer);
9300 <Option<u64>>::sse_encode(self.htlc_minimum_msat, serializer);
9301 <Option<u64>>::sse_encode(self.htlc_maximum_msat, serializer);
9302 }
9303}
9304
9305impl SseEncode for crate::error::SdkError {
9306 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9308 match self {
9309 crate::error::SdkError::AlreadyStarted => {
9310 <i32>::sse_encode(0, serializer);
9311 }
9312 crate::error::SdkError::Generic { err } => {
9313 <i32>::sse_encode(1, serializer);
9314 <String>::sse_encode(err, serializer);
9315 }
9316 crate::error::SdkError::NotStarted => {
9317 <i32>::sse_encode(2, serializer);
9318 }
9319 crate::error::SdkError::ServiceConnectivity { err } => {
9320 <i32>::sse_encode(3, serializer);
9321 <String>::sse_encode(err, serializer);
9322 }
9323 _ => {
9324 unimplemented!("");
9325 }
9326 }
9327 }
9328}
9329
9330impl SseEncode for crate::model::SdkEvent {
9331 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9333 match self {
9334 crate::model::SdkEvent::PaymentFailed { details } => {
9335 <i32>::sse_encode(0, serializer);
9336 <crate::model::Payment>::sse_encode(details, serializer);
9337 }
9338 crate::model::SdkEvent::PaymentPending { details } => {
9339 <i32>::sse_encode(1, serializer);
9340 <crate::model::Payment>::sse_encode(details, serializer);
9341 }
9342 crate::model::SdkEvent::PaymentRefundable { details } => {
9343 <i32>::sse_encode(2, serializer);
9344 <crate::model::Payment>::sse_encode(details, serializer);
9345 }
9346 crate::model::SdkEvent::PaymentRefunded { details } => {
9347 <i32>::sse_encode(3, serializer);
9348 <crate::model::Payment>::sse_encode(details, serializer);
9349 }
9350 crate::model::SdkEvent::PaymentRefundPending { details } => {
9351 <i32>::sse_encode(4, serializer);
9352 <crate::model::Payment>::sse_encode(details, serializer);
9353 }
9354 crate::model::SdkEvent::PaymentSucceeded { details } => {
9355 <i32>::sse_encode(5, serializer);
9356 <crate::model::Payment>::sse_encode(details, serializer);
9357 }
9358 crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
9359 <i32>::sse_encode(6, serializer);
9360 <crate::model::Payment>::sse_encode(details, serializer);
9361 }
9362 crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
9363 <i32>::sse_encode(7, serializer);
9364 <crate::model::Payment>::sse_encode(details, serializer);
9365 }
9366 crate::model::SdkEvent::Synced => {
9367 <i32>::sse_encode(8, serializer);
9368 }
9369 crate::model::SdkEvent::DataSynced {
9370 did_pull_new_records,
9371 } => {
9372 <i32>::sse_encode(9, serializer);
9373 <bool>::sse_encode(did_pull_new_records, serializer);
9374 }
9375 _ => {
9376 unimplemented!("");
9377 }
9378 }
9379 }
9380}
9381
9382impl SseEncode for crate::model::SendDestination {
9383 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9385 match self {
9386 crate::model::SendDestination::LiquidAddress {
9387 address_data,
9388 bip353_address,
9389 } => {
9390 <i32>::sse_encode(0, serializer);
9391 <crate::bindings::LiquidAddressData>::sse_encode(address_data, serializer);
9392 <Option<String>>::sse_encode(bip353_address, serializer);
9393 }
9394 crate::model::SendDestination::Bolt11 {
9395 invoice,
9396 bip353_address,
9397 } => {
9398 <i32>::sse_encode(1, serializer);
9399 <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
9400 <Option<String>>::sse_encode(bip353_address, serializer);
9401 }
9402 crate::model::SendDestination::Bolt12 {
9403 offer,
9404 receiver_amount_sat,
9405 bip353_address,
9406 } => {
9407 <i32>::sse_encode(2, serializer);
9408 <crate::bindings::LNOffer>::sse_encode(offer, serializer);
9409 <u64>::sse_encode(receiver_amount_sat, serializer);
9410 <Option<String>>::sse_encode(bip353_address, serializer);
9411 }
9412 _ => {
9413 unimplemented!("");
9414 }
9415 }
9416 }
9417}
9418
9419impl SseEncode for crate::model::SendPaymentRequest {
9420 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9422 <crate::model::PrepareSendResponse>::sse_encode(self.prepare_response, serializer);
9423 <Option<bool>>::sse_encode(self.use_asset_fees, serializer);
9424 <Option<String>>::sse_encode(self.payer_note, serializer);
9425 }
9426}
9427
9428impl SseEncode for crate::model::SendPaymentResponse {
9429 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9431 <crate::model::Payment>::sse_encode(self.payment, serializer);
9432 }
9433}
9434
9435impl SseEncode for crate::model::SignMessageRequest {
9436 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9438 <String>::sse_encode(self.message, serializer);
9439 }
9440}
9441
9442impl SseEncode for crate::model::SignMessageResponse {
9443 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9445 <String>::sse_encode(self.signature, serializer);
9446 }
9447}
9448
9449impl SseEncode for crate::bindings::SuccessAction {
9450 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9452 match self {
9453 crate::bindings::SuccessAction::Aes { data } => {
9454 <i32>::sse_encode(0, serializer);
9455 <crate::bindings::AesSuccessActionData>::sse_encode(data, serializer);
9456 }
9457 crate::bindings::SuccessAction::Message { data } => {
9458 <i32>::sse_encode(1, serializer);
9459 <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9460 }
9461 crate::bindings::SuccessAction::Url { data } => {
9462 <i32>::sse_encode(2, serializer);
9463 <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9464 }
9465 _ => {
9466 unimplemented!("");
9467 }
9468 }
9469 }
9470}
9471
9472impl SseEncode for crate::bindings::SuccessActionProcessed {
9473 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9475 match self {
9476 crate::bindings::SuccessActionProcessed::Aes { result } => {
9477 <i32>::sse_encode(0, serializer);
9478 <crate::bindings::AesSuccessActionDataResult>::sse_encode(result, serializer);
9479 }
9480 crate::bindings::SuccessActionProcessed::Message { data } => {
9481 <i32>::sse_encode(1, serializer);
9482 <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9483 }
9484 crate::bindings::SuccessActionProcessed::Url { data } => {
9485 <i32>::sse_encode(2, serializer);
9486 <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9487 }
9488 _ => {
9489 unimplemented!("");
9490 }
9491 }
9492 }
9493}
9494
9495impl SseEncode for crate::bindings::Symbol {
9496 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9498 <Option<String>>::sse_encode(self.grapheme, serializer);
9499 <Option<String>>::sse_encode(self.template, serializer);
9500 <Option<bool>>::sse_encode(self.rtl, serializer);
9501 <Option<u32>>::sse_encode(self.position, serializer);
9502 }
9503}
9504
9505impl SseEncode for u16 {
9506 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9508 serializer.cursor.write_u16::<NativeEndian>(self).unwrap();
9509 }
9510}
9511
9512impl SseEncode for u32 {
9513 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9515 serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
9516 }
9517}
9518
9519impl SseEncode for u64 {
9520 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9522 serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
9523 }
9524}
9525
9526impl SseEncode for u8 {
9527 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9529 serializer.cursor.write_u8(self).unwrap();
9530 }
9531}
9532
9533impl SseEncode for () {
9534 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
9536}
9537
9538impl SseEncode for crate::bindings::UrlSuccessActionData {
9539 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9541 <String>::sse_encode(self.description, serializer);
9542 <String>::sse_encode(self.url, serializer);
9543 <bool>::sse_encode(self.matches_callback_domain, serializer);
9544 }
9545}
9546
9547impl SseEncode for usize {
9548 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9550 serializer
9551 .cursor
9552 .write_u64::<NativeEndian>(self as _)
9553 .unwrap();
9554 }
9555}
9556
9557impl SseEncode for crate::model::WalletInfo {
9558 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9560 <u64>::sse_encode(self.balance_sat, serializer);
9561 <u64>::sse_encode(self.pending_send_sat, serializer);
9562 <u64>::sse_encode(self.pending_receive_sat, serializer);
9563 <String>::sse_encode(self.fingerprint, serializer);
9564 <String>::sse_encode(self.pubkey, serializer);
9565 <Vec<crate::model::AssetBalance>>::sse_encode(self.asset_balances, serializer);
9566 }
9567}
9568
9569#[cfg(not(target_family = "wasm"))]
9570mod io {
9571 use super::*;
9577 use crate::bindings::*;
9578 use crate::model::EventListener;
9579 use flutter_rust_bridge::for_generated::byteorder::{
9580 NativeEndian, ReadBytesExt, WriteBytesExt,
9581 };
9582 use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
9583 use flutter_rust_bridge::{Handler, IntoIntoDart};
9584
9585 flutter_rust_bridge::frb_generated_boilerplate_io!();
9588
9589 impl CstDecode<flutter_rust_bridge::for_generated::anyhow::Error>
9592 for *mut wire_cst_list_prim_u_8_strict
9593 {
9594 fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error {
9596 unimplemented!()
9597 }
9598 }
9599 impl CstDecode<BindingLiquidSdk> for usize {
9600 fn cst_decode(self) -> BindingLiquidSdk {
9602 flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::<
9603 RustOpaqueNom<
9604 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9605 >,
9606 >::cst_decode(
9607 self
9608 ))
9609 }
9610 }
9611 impl
9612 CstDecode<
9613 RustOpaqueNom<
9614 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9615 >,
9616 > for usize
9617 {
9618 fn cst_decode(
9620 self,
9621 ) -> RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
9622 {
9623 unsafe { decode_rust_opaque_nom(self as _) }
9624 }
9625 }
9626 impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>
9627 for *mut wire_cst_list_prim_u_8_strict
9628 {
9629 fn cst_decode(
9631 self,
9632 ) -> StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
9633 {
9634 let raw: String = self.cst_decode();
9635 StreamSink::deserialize(raw)
9636 }
9637 }
9638 impl CstDecode<StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>>
9639 for *mut wire_cst_list_prim_u_8_strict
9640 {
9641 fn cst_decode(
9643 self,
9644 ) -> StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
9645 {
9646 let raw: String = self.cst_decode();
9647 StreamSink::deserialize(raw)
9648 }
9649 }
9650 impl CstDecode<String> for *mut wire_cst_list_prim_u_8_strict {
9651 fn cst_decode(self) -> String {
9653 let vec: Vec<u8> = self.cst_decode();
9654 String::from_utf8(vec).unwrap()
9655 }
9656 }
9657 impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9658 for wire_cst_accept_payment_proposed_fees_request
9659 {
9660 fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9662 crate::model::AcceptPaymentProposedFeesRequest {
9663 response: self.response.cst_decode(),
9664 }
9665 }
9666 }
9667 impl CstDecode<crate::bindings::AesSuccessActionData> for wire_cst_aes_success_action_data {
9668 fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9670 crate::bindings::AesSuccessActionData {
9671 description: self.description.cst_decode(),
9672 ciphertext: self.ciphertext.cst_decode(),
9673 iv: self.iv.cst_decode(),
9674 }
9675 }
9676 }
9677 impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9678 for wire_cst_aes_success_action_data_decrypted
9679 {
9680 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9682 crate::bindings::AesSuccessActionDataDecrypted {
9683 description: self.description.cst_decode(),
9684 plaintext: self.plaintext.cst_decode(),
9685 }
9686 }
9687 }
9688 impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9689 for wire_cst_aes_success_action_data_result
9690 {
9691 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9693 match self.tag {
9694 0 => {
9695 let ans = unsafe { self.kind.Decrypted };
9696 crate::bindings::AesSuccessActionDataResult::Decrypted {
9697 data: ans.data.cst_decode(),
9698 }
9699 }
9700 1 => {
9701 let ans = unsafe { self.kind.ErrorStatus };
9702 crate::bindings::AesSuccessActionDataResult::ErrorStatus {
9703 reason: ans.reason.cst_decode(),
9704 }
9705 }
9706 _ => unreachable!(),
9707 }
9708 }
9709 }
9710 impl CstDecode<crate::bindings::Amount> for wire_cst_amount {
9711 fn cst_decode(self) -> crate::bindings::Amount {
9713 match self.tag {
9714 0 => {
9715 let ans = unsafe { self.kind.Bitcoin };
9716 crate::bindings::Amount::Bitcoin {
9717 amount_msat: ans.amount_msat.cst_decode(),
9718 }
9719 }
9720 1 => {
9721 let ans = unsafe { self.kind.Currency };
9722 crate::bindings::Amount::Currency {
9723 iso4217_code: ans.iso4217_code.cst_decode(),
9724 fractional_amount: ans.fractional_amount.cst_decode(),
9725 }
9726 }
9727 _ => unreachable!(),
9728 }
9729 }
9730 }
9731 impl CstDecode<crate::model::AssetBalance> for wire_cst_asset_balance {
9732 fn cst_decode(self) -> crate::model::AssetBalance {
9734 crate::model::AssetBalance {
9735 asset_id: self.asset_id.cst_decode(),
9736 balance_sat: self.balance_sat.cst_decode(),
9737 name: self.name.cst_decode(),
9738 ticker: self.ticker.cst_decode(),
9739 balance: self.balance.cst_decode(),
9740 }
9741 }
9742 }
9743 impl CstDecode<crate::model::AssetInfo> for wire_cst_asset_info {
9744 fn cst_decode(self) -> crate::model::AssetInfo {
9746 crate::model::AssetInfo {
9747 name: self.name.cst_decode(),
9748 ticker: self.ticker.cst_decode(),
9749 amount: self.amount.cst_decode(),
9750 fees: self.fees.cst_decode(),
9751 }
9752 }
9753 }
9754 impl CstDecode<crate::model::AssetMetadata> for wire_cst_asset_metadata {
9755 fn cst_decode(self) -> crate::model::AssetMetadata {
9757 crate::model::AssetMetadata {
9758 asset_id: self.asset_id.cst_decode(),
9759 name: self.name.cst_decode(),
9760 ticker: self.ticker.cst_decode(),
9761 precision: self.precision.cst_decode(),
9762 fiat_id: self.fiat_id.cst_decode(),
9763 }
9764 }
9765 }
9766 impl CstDecode<crate::model::BackupRequest> for wire_cst_backup_request {
9767 fn cst_decode(self) -> crate::model::BackupRequest {
9769 crate::model::BackupRequest {
9770 backup_path: self.backup_path.cst_decode(),
9771 }
9772 }
9773 }
9774 impl CstDecode<crate::bindings::BindingEventListener> for wire_cst_binding_event_listener {
9775 fn cst_decode(self) -> crate::bindings::BindingEventListener {
9777 crate::bindings::BindingEventListener {
9778 stream: self.stream.cst_decode(),
9779 }
9780 }
9781 }
9782 impl CstDecode<crate::bindings::BitcoinAddressData> for wire_cst_bitcoin_address_data {
9783 fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9785 crate::bindings::BitcoinAddressData {
9786 address: self.address.cst_decode(),
9787 network: self.network.cst_decode(),
9788 amount_sat: self.amount_sat.cst_decode(),
9789 label: self.label.cst_decode(),
9790 message: self.message.cst_decode(),
9791 }
9792 }
9793 }
9794 impl CstDecode<crate::model::BlockchainExplorer> for wire_cst_blockchain_explorer {
9795 fn cst_decode(self) -> crate::model::BlockchainExplorer {
9797 match self.tag {
9798 0 => {
9799 let ans = unsafe { self.kind.Electrum };
9800 crate::model::BlockchainExplorer::Electrum {
9801 url: ans.url.cst_decode(),
9802 }
9803 }
9804 1 => {
9805 let ans = unsafe { self.kind.Esplora };
9806 crate::model::BlockchainExplorer::Esplora {
9807 url: ans.url.cst_decode(),
9808 use_waterfalls: ans.use_waterfalls.cst_decode(),
9809 }
9810 }
9811 _ => unreachable!(),
9812 }
9813 }
9814 }
9815 impl CstDecode<crate::model::BlockchainInfo> for wire_cst_blockchain_info {
9816 fn cst_decode(self) -> crate::model::BlockchainInfo {
9818 crate::model::BlockchainInfo {
9819 liquid_tip: self.liquid_tip.cst_decode(),
9820 bitcoin_tip: self.bitcoin_tip.cst_decode(),
9821 }
9822 }
9823 }
9824 impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9825 for *mut wire_cst_accept_payment_proposed_fees_request
9826 {
9827 fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9829 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9830 CstDecode::<crate::model::AcceptPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9831 }
9832 }
9833 impl CstDecode<crate::bindings::AesSuccessActionData> for *mut wire_cst_aes_success_action_data {
9834 fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9836 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9837 CstDecode::<crate::bindings::AesSuccessActionData>::cst_decode(*wrap).into()
9838 }
9839 }
9840 impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9841 for *mut wire_cst_aes_success_action_data_decrypted
9842 {
9843 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9845 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9846 CstDecode::<crate::bindings::AesSuccessActionDataDecrypted>::cst_decode(*wrap).into()
9847 }
9848 }
9849 impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9850 for *mut wire_cst_aes_success_action_data_result
9851 {
9852 fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9854 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9855 CstDecode::<crate::bindings::AesSuccessActionDataResult>::cst_decode(*wrap).into()
9856 }
9857 }
9858 impl CstDecode<crate::bindings::Amount> for *mut wire_cst_amount {
9859 fn cst_decode(self) -> crate::bindings::Amount {
9861 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9862 CstDecode::<crate::bindings::Amount>::cst_decode(*wrap).into()
9863 }
9864 }
9865 impl CstDecode<crate::model::AssetInfo> for *mut wire_cst_asset_info {
9866 fn cst_decode(self) -> crate::model::AssetInfo {
9868 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9869 CstDecode::<crate::model::AssetInfo>::cst_decode(*wrap).into()
9870 }
9871 }
9872 impl CstDecode<crate::model::BackupRequest> for *mut wire_cst_backup_request {
9873 fn cst_decode(self) -> crate::model::BackupRequest {
9875 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9876 CstDecode::<crate::model::BackupRequest>::cst_decode(*wrap).into()
9877 }
9878 }
9879 impl CstDecode<crate::bindings::BindingEventListener> for *mut wire_cst_binding_event_listener {
9880 fn cst_decode(self) -> crate::bindings::BindingEventListener {
9882 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9883 CstDecode::<crate::bindings::BindingEventListener>::cst_decode(*wrap).into()
9884 }
9885 }
9886 impl CstDecode<crate::bindings::BitcoinAddressData> for *mut wire_cst_bitcoin_address_data {
9887 fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9889 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9890 CstDecode::<crate::bindings::BitcoinAddressData>::cst_decode(*wrap).into()
9891 }
9892 }
9893 impl CstDecode<bool> for *mut bool {
9894 fn cst_decode(self) -> bool {
9896 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9897 }
9898 }
9899 impl CstDecode<crate::model::BuyBitcoinRequest> for *mut wire_cst_buy_bitcoin_request {
9900 fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
9902 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9903 CstDecode::<crate::model::BuyBitcoinRequest>::cst_decode(*wrap).into()
9904 }
9905 }
9906 impl CstDecode<crate::model::CheckMessageRequest> for *mut wire_cst_check_message_request {
9907 fn cst_decode(self) -> crate::model::CheckMessageRequest {
9909 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9910 CstDecode::<crate::model::CheckMessageRequest>::cst_decode(*wrap).into()
9911 }
9912 }
9913 impl CstDecode<crate::model::ConnectRequest> for *mut wire_cst_connect_request {
9914 fn cst_decode(self) -> crate::model::ConnectRequest {
9916 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9917 CstDecode::<crate::model::ConnectRequest>::cst_decode(*wrap).into()
9918 }
9919 }
9920 impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
9921 for *mut wire_cst_create_bolt_12_invoice_request
9922 {
9923 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
9925 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9926 CstDecode::<crate::model::CreateBolt12InvoiceRequest>::cst_decode(*wrap).into()
9927 }
9928 }
9929 impl CstDecode<f64> for *mut f64 {
9930 fn cst_decode(self) -> f64 {
9932 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9933 }
9934 }
9935 impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
9936 for *mut wire_cst_fetch_payment_proposed_fees_request
9937 {
9938 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
9940 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9941 CstDecode::<crate::model::FetchPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9942 }
9943 }
9944 impl CstDecode<crate::model::GetPaymentRequest> for *mut wire_cst_get_payment_request {
9945 fn cst_decode(self) -> crate::model::GetPaymentRequest {
9947 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9948 CstDecode::<crate::model::GetPaymentRequest>::cst_decode(*wrap).into()
9949 }
9950 }
9951 impl CstDecode<i64> for *mut i64 {
9952 fn cst_decode(self) -> i64 {
9954 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9955 }
9956 }
9957 impl CstDecode<crate::bindings::LiquidAddressData> for *mut wire_cst_liquid_address_data {
9958 fn cst_decode(self) -> crate::bindings::LiquidAddressData {
9960 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9961 CstDecode::<crate::bindings::LiquidAddressData>::cst_decode(*wrap).into()
9962 }
9963 }
9964 impl CstDecode<crate::model::ListPaymentDetails> for *mut wire_cst_list_payment_details {
9965 fn cst_decode(self) -> crate::model::ListPaymentDetails {
9967 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9968 CstDecode::<crate::model::ListPaymentDetails>::cst_decode(*wrap).into()
9969 }
9970 }
9971 impl CstDecode<crate::model::ListPaymentsRequest> for *mut wire_cst_list_payments_request {
9972 fn cst_decode(self) -> crate::model::ListPaymentsRequest {
9974 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9975 CstDecode::<crate::model::ListPaymentsRequest>::cst_decode(*wrap).into()
9976 }
9977 }
9978 impl CstDecode<crate::bindings::LNInvoice> for *mut wire_cst_ln_invoice {
9979 fn cst_decode(self) -> crate::bindings::LNInvoice {
9981 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9982 CstDecode::<crate::bindings::LNInvoice>::cst_decode(*wrap).into()
9983 }
9984 }
9985 impl CstDecode<crate::bindings::LNOffer> for *mut wire_cst_ln_offer {
9986 fn cst_decode(self) -> crate::bindings::LNOffer {
9988 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9989 CstDecode::<crate::bindings::LNOffer>::cst_decode(*wrap).into()
9990 }
9991 }
9992 impl CstDecode<crate::bindings::LnUrlAuthRequestData> for *mut wire_cst_ln_url_auth_request_data {
9993 fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
9995 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9996 CstDecode::<crate::bindings::LnUrlAuthRequestData>::cst_decode(*wrap).into()
9997 }
9998 }
9999 impl CstDecode<crate::bindings::LnUrlErrorData> for *mut wire_cst_ln_url_error_data {
10000 fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10002 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10003 CstDecode::<crate::bindings::LnUrlErrorData>::cst_decode(*wrap).into()
10004 }
10005 }
10006 impl CstDecode<crate::model::LnUrlInfo> for *mut wire_cst_ln_url_info {
10007 fn cst_decode(self) -> crate::model::LnUrlInfo {
10009 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10010 CstDecode::<crate::model::LnUrlInfo>::cst_decode(*wrap).into()
10011 }
10012 }
10013 impl CstDecode<crate::bindings::LnUrlPayErrorData> for *mut wire_cst_ln_url_pay_error_data {
10014 fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10016 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10017 CstDecode::<crate::bindings::LnUrlPayErrorData>::cst_decode(*wrap).into()
10018 }
10019 }
10020 impl CstDecode<crate::model::LnUrlPayRequest> for *mut wire_cst_ln_url_pay_request {
10021 fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10023 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10024 CstDecode::<crate::model::LnUrlPayRequest>::cst_decode(*wrap).into()
10025 }
10026 }
10027 impl CstDecode<crate::bindings::LnUrlPayRequestData> for *mut wire_cst_ln_url_pay_request_data {
10028 fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10030 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10031 CstDecode::<crate::bindings::LnUrlPayRequestData>::cst_decode(*wrap).into()
10032 }
10033 }
10034 impl CstDecode<crate::model::LnUrlPaySuccessData> for *mut wire_cst_ln_url_pay_success_data {
10035 fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10037 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10038 CstDecode::<crate::model::LnUrlPaySuccessData>::cst_decode(*wrap).into()
10039 }
10040 }
10041 impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for *mut wire_cst_ln_url_withdraw_request {
10042 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
10044 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10045 CstDecode::<crate::bindings::LnUrlWithdrawRequest>::cst_decode(*wrap).into()
10046 }
10047 }
10048 impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
10049 for *mut wire_cst_ln_url_withdraw_request_data
10050 {
10051 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
10053 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10054 CstDecode::<crate::bindings::LnUrlWithdrawRequestData>::cst_decode(*wrap).into()
10055 }
10056 }
10057 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
10058 for *mut wire_cst_ln_url_withdraw_success_data
10059 {
10060 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
10062 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10063 CstDecode::<crate::bindings::duplicates::LnUrlWithdrawSuccessData>::cst_decode(*wrap)
10064 .into()
10065 }
10066 }
10067 impl CstDecode<crate::bindings::MessageSuccessActionData>
10068 for *mut wire_cst_message_success_action_data
10069 {
10070 fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
10072 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10073 CstDecode::<crate::bindings::MessageSuccessActionData>::cst_decode(*wrap).into()
10074 }
10075 }
10076 impl CstDecode<crate::model::PayAmount> for *mut wire_cst_pay_amount {
10077 fn cst_decode(self) -> crate::model::PayAmount {
10079 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10080 CstDecode::<crate::model::PayAmount>::cst_decode(*wrap).into()
10081 }
10082 }
10083 impl CstDecode<crate::model::PayOnchainRequest> for *mut wire_cst_pay_onchain_request {
10084 fn cst_decode(self) -> crate::model::PayOnchainRequest {
10086 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10087 CstDecode::<crate::model::PayOnchainRequest>::cst_decode(*wrap).into()
10088 }
10089 }
10090 impl CstDecode<crate::model::Payment> for *mut wire_cst_payment {
10091 fn cst_decode(self) -> crate::model::Payment {
10093 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10094 CstDecode::<crate::model::Payment>::cst_decode(*wrap).into()
10095 }
10096 }
10097 impl CstDecode<crate::model::PrepareBuyBitcoinRequest>
10098 for *mut wire_cst_prepare_buy_bitcoin_request
10099 {
10100 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
10102 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10103 CstDecode::<crate::model::PrepareBuyBitcoinRequest>::cst_decode(*wrap).into()
10104 }
10105 }
10106 impl CstDecode<crate::model::PrepareLnUrlPayRequest> for *mut wire_cst_prepare_ln_url_pay_request {
10107 fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
10109 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10110 CstDecode::<crate::model::PrepareLnUrlPayRequest>::cst_decode(*wrap).into()
10111 }
10112 }
10113 impl CstDecode<crate::model::PreparePayOnchainRequest>
10114 for *mut wire_cst_prepare_pay_onchain_request
10115 {
10116 fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
10118 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10119 CstDecode::<crate::model::PreparePayOnchainRequest>::cst_decode(*wrap).into()
10120 }
10121 }
10122 impl CstDecode<crate::model::PrepareReceiveRequest> for *mut wire_cst_prepare_receive_request {
10123 fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
10125 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10126 CstDecode::<crate::model::PrepareReceiveRequest>::cst_decode(*wrap).into()
10127 }
10128 }
10129 impl CstDecode<crate::model::PrepareRefundRequest> for *mut wire_cst_prepare_refund_request {
10130 fn cst_decode(self) -> crate::model::PrepareRefundRequest {
10132 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10133 CstDecode::<crate::model::PrepareRefundRequest>::cst_decode(*wrap).into()
10134 }
10135 }
10136 impl CstDecode<crate::model::PrepareSendRequest> for *mut wire_cst_prepare_send_request {
10137 fn cst_decode(self) -> crate::model::PrepareSendRequest {
10139 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10140 CstDecode::<crate::model::PrepareSendRequest>::cst_decode(*wrap).into()
10141 }
10142 }
10143 impl CstDecode<crate::model::ReceiveAmount> for *mut wire_cst_receive_amount {
10144 fn cst_decode(self) -> crate::model::ReceiveAmount {
10146 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10147 CstDecode::<crate::model::ReceiveAmount>::cst_decode(*wrap).into()
10148 }
10149 }
10150 impl CstDecode<crate::model::ReceivePaymentRequest> for *mut wire_cst_receive_payment_request {
10151 fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
10153 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10154 CstDecode::<crate::model::ReceivePaymentRequest>::cst_decode(*wrap).into()
10155 }
10156 }
10157 impl CstDecode<crate::model::RefundRequest> for *mut wire_cst_refund_request {
10158 fn cst_decode(self) -> crate::model::RefundRequest {
10160 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10161 CstDecode::<crate::model::RefundRequest>::cst_decode(*wrap).into()
10162 }
10163 }
10164 impl CstDecode<crate::model::RestoreRequest> for *mut wire_cst_restore_request {
10165 fn cst_decode(self) -> crate::model::RestoreRequest {
10167 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10168 CstDecode::<crate::model::RestoreRequest>::cst_decode(*wrap).into()
10169 }
10170 }
10171 impl CstDecode<crate::model::SdkEvent> for *mut wire_cst_sdk_event {
10172 fn cst_decode(self) -> crate::model::SdkEvent {
10174 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10175 CstDecode::<crate::model::SdkEvent>::cst_decode(*wrap).into()
10176 }
10177 }
10178 impl CstDecode<crate::model::SendPaymentRequest> for *mut wire_cst_send_payment_request {
10179 fn cst_decode(self) -> crate::model::SendPaymentRequest {
10181 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10182 CstDecode::<crate::model::SendPaymentRequest>::cst_decode(*wrap).into()
10183 }
10184 }
10185 impl CstDecode<crate::model::SignMessageRequest> for *mut wire_cst_sign_message_request {
10186 fn cst_decode(self) -> crate::model::SignMessageRequest {
10188 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10189 CstDecode::<crate::model::SignMessageRequest>::cst_decode(*wrap).into()
10190 }
10191 }
10192 impl CstDecode<crate::bindings::SuccessAction> for *mut wire_cst_success_action {
10193 fn cst_decode(self) -> crate::bindings::SuccessAction {
10195 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10196 CstDecode::<crate::bindings::SuccessAction>::cst_decode(*wrap).into()
10197 }
10198 }
10199 impl CstDecode<crate::bindings::SuccessActionProcessed> for *mut wire_cst_success_action_processed {
10200 fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
10202 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10203 CstDecode::<crate::bindings::SuccessActionProcessed>::cst_decode(*wrap).into()
10204 }
10205 }
10206 impl CstDecode<crate::bindings::Symbol> for *mut wire_cst_symbol {
10207 fn cst_decode(self) -> crate::bindings::Symbol {
10209 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10210 CstDecode::<crate::bindings::Symbol>::cst_decode(*wrap).into()
10211 }
10212 }
10213 impl CstDecode<u32> for *mut u32 {
10214 fn cst_decode(self) -> u32 {
10216 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10217 }
10218 }
10219 impl CstDecode<u64> for *mut u64 {
10220 fn cst_decode(self) -> u64 {
10222 unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10223 }
10224 }
10225 impl CstDecode<crate::bindings::UrlSuccessActionData> for *mut wire_cst_url_success_action_data {
10226 fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
10228 let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10229 CstDecode::<crate::bindings::UrlSuccessActionData>::cst_decode(*wrap).into()
10230 }
10231 }
10232 impl CstDecode<crate::model::BuyBitcoinRequest> for wire_cst_buy_bitcoin_request {
10233 fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
10235 crate::model::BuyBitcoinRequest {
10236 prepare_response: self.prepare_response.cst_decode(),
10237 redirect_url: self.redirect_url.cst_decode(),
10238 }
10239 }
10240 }
10241 impl CstDecode<crate::model::CheckMessageRequest> for wire_cst_check_message_request {
10242 fn cst_decode(self) -> crate::model::CheckMessageRequest {
10244 crate::model::CheckMessageRequest {
10245 message: self.message.cst_decode(),
10246 pubkey: self.pubkey.cst_decode(),
10247 signature: self.signature.cst_decode(),
10248 }
10249 }
10250 }
10251 impl CstDecode<crate::model::CheckMessageResponse> for wire_cst_check_message_response {
10252 fn cst_decode(self) -> crate::model::CheckMessageResponse {
10254 crate::model::CheckMessageResponse {
10255 is_valid: self.is_valid.cst_decode(),
10256 }
10257 }
10258 }
10259 impl CstDecode<crate::model::Config> for wire_cst_config {
10260 fn cst_decode(self) -> crate::model::Config {
10262 crate::model::Config {
10263 liquid_explorer: self.liquid_explorer.cst_decode(),
10264 bitcoin_explorer: self.bitcoin_explorer.cst_decode(),
10265 working_dir: self.working_dir.cst_decode(),
10266 network: self.network.cst_decode(),
10267 payment_timeout_sec: self.payment_timeout_sec.cst_decode(),
10268 sync_service_url: self.sync_service_url.cst_decode(),
10269 zero_conf_max_amount_sat: self.zero_conf_max_amount_sat.cst_decode(),
10270 breez_api_key: self.breez_api_key.cst_decode(),
10271 external_input_parsers: self.external_input_parsers.cst_decode(),
10272 use_default_external_input_parsers: self
10273 .use_default_external_input_parsers
10274 .cst_decode(),
10275 onchain_fee_rate_leeway_sat: self.onchain_fee_rate_leeway_sat.cst_decode(),
10276 asset_metadata: self.asset_metadata.cst_decode(),
10277 sideswap_api_key: self.sideswap_api_key.cst_decode(),
10278 }
10279 }
10280 }
10281 impl CstDecode<crate::model::ConnectRequest> for wire_cst_connect_request {
10282 fn cst_decode(self) -> crate::model::ConnectRequest {
10284 crate::model::ConnectRequest {
10285 config: self.config.cst_decode(),
10286 mnemonic: self.mnemonic.cst_decode(),
10287 passphrase: self.passphrase.cst_decode(),
10288 seed: self.seed.cst_decode(),
10289 }
10290 }
10291 }
10292 impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
10293 for wire_cst_create_bolt_12_invoice_request
10294 {
10295 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
10297 crate::model::CreateBolt12InvoiceRequest {
10298 offer: self.offer.cst_decode(),
10299 invoice_request: self.invoice_request.cst_decode(),
10300 }
10301 }
10302 }
10303 impl CstDecode<crate::model::CreateBolt12InvoiceResponse>
10304 for wire_cst_create_bolt_12_invoice_response
10305 {
10306 fn cst_decode(self) -> crate::model::CreateBolt12InvoiceResponse {
10308 crate::model::CreateBolt12InvoiceResponse {
10309 invoice: self.invoice.cst_decode(),
10310 }
10311 }
10312 }
10313 impl CstDecode<crate::bindings::CurrencyInfo> for wire_cst_currency_info {
10314 fn cst_decode(self) -> crate::bindings::CurrencyInfo {
10316 crate::bindings::CurrencyInfo {
10317 name: self.name.cst_decode(),
10318 fraction_size: self.fraction_size.cst_decode(),
10319 spacing: self.spacing.cst_decode(),
10320 symbol: self.symbol.cst_decode(),
10321 uniq_symbol: self.uniq_symbol.cst_decode(),
10322 localized_name: self.localized_name.cst_decode(),
10323 locale_overrides: self.locale_overrides.cst_decode(),
10324 }
10325 }
10326 }
10327 impl CstDecode<crate::bindings::ExternalInputParser> for wire_cst_external_input_parser {
10328 fn cst_decode(self) -> crate::bindings::ExternalInputParser {
10330 crate::bindings::ExternalInputParser {
10331 provider_id: self.provider_id.cst_decode(),
10332 input_regex: self.input_regex.cst_decode(),
10333 parser_url: self.parser_url.cst_decode(),
10334 }
10335 }
10336 }
10337 impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
10338 for wire_cst_fetch_payment_proposed_fees_request
10339 {
10340 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
10342 crate::model::FetchPaymentProposedFeesRequest {
10343 swap_id: self.swap_id.cst_decode(),
10344 }
10345 }
10346 }
10347 impl CstDecode<crate::model::FetchPaymentProposedFeesResponse>
10348 for wire_cst_fetch_payment_proposed_fees_response
10349 {
10350 fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesResponse {
10352 crate::model::FetchPaymentProposedFeesResponse {
10353 swap_id: self.swap_id.cst_decode(),
10354 fees_sat: self.fees_sat.cst_decode(),
10355 payer_amount_sat: self.payer_amount_sat.cst_decode(),
10356 receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
10357 }
10358 }
10359 }
10360 impl CstDecode<crate::bindings::FiatCurrency> for wire_cst_fiat_currency {
10361 fn cst_decode(self) -> crate::bindings::FiatCurrency {
10363 crate::bindings::FiatCurrency {
10364 id: self.id.cst_decode(),
10365 info: self.info.cst_decode(),
10366 }
10367 }
10368 }
10369 impl CstDecode<crate::model::GetInfoResponse> for wire_cst_get_info_response {
10370 fn cst_decode(self) -> crate::model::GetInfoResponse {
10372 crate::model::GetInfoResponse {
10373 wallet_info: self.wallet_info.cst_decode(),
10374 blockchain_info: self.blockchain_info.cst_decode(),
10375 }
10376 }
10377 }
10378 impl CstDecode<crate::model::GetPaymentRequest> for wire_cst_get_payment_request {
10379 fn cst_decode(self) -> crate::model::GetPaymentRequest {
10381 match self.tag {
10382 0 => {
10383 let ans = unsafe { self.kind.PaymentHash };
10384 crate::model::GetPaymentRequest::PaymentHash {
10385 payment_hash: ans.payment_hash.cst_decode(),
10386 }
10387 }
10388 1 => {
10389 let ans = unsafe { self.kind.SwapId };
10390 crate::model::GetPaymentRequest::SwapId {
10391 swap_id: ans.swap_id.cst_decode(),
10392 }
10393 }
10394 _ => unreachable!(),
10395 }
10396 }
10397 }
10398 impl CstDecode<crate::bindings::InputType> for wire_cst_input_type {
10399 fn cst_decode(self) -> crate::bindings::InputType {
10401 match self.tag {
10402 0 => {
10403 let ans = unsafe { self.kind.BitcoinAddress };
10404 crate::bindings::InputType::BitcoinAddress {
10405 address: ans.address.cst_decode(),
10406 }
10407 }
10408 1 => {
10409 let ans = unsafe { self.kind.LiquidAddress };
10410 crate::bindings::InputType::LiquidAddress {
10411 address: ans.address.cst_decode(),
10412 }
10413 }
10414 2 => {
10415 let ans = unsafe { self.kind.Bolt11 };
10416 crate::bindings::InputType::Bolt11 {
10417 invoice: ans.invoice.cst_decode(),
10418 }
10419 }
10420 3 => {
10421 let ans = unsafe { self.kind.Bolt12Offer };
10422 crate::bindings::InputType::Bolt12Offer {
10423 offer: ans.offer.cst_decode(),
10424 bip353_address: ans.bip353_address.cst_decode(),
10425 }
10426 }
10427 4 => {
10428 let ans = unsafe { self.kind.NodeId };
10429 crate::bindings::InputType::NodeId {
10430 node_id: ans.node_id.cst_decode(),
10431 }
10432 }
10433 5 => {
10434 let ans = unsafe { self.kind.Url };
10435 crate::bindings::InputType::Url {
10436 url: ans.url.cst_decode(),
10437 }
10438 }
10439 6 => {
10440 let ans = unsafe { self.kind.LnUrlPay };
10441 crate::bindings::InputType::LnUrlPay {
10442 data: ans.data.cst_decode(),
10443 bip353_address: ans.bip353_address.cst_decode(),
10444 }
10445 }
10446 7 => {
10447 let ans = unsafe { self.kind.LnUrlWithdraw };
10448 crate::bindings::InputType::LnUrlWithdraw {
10449 data: ans.data.cst_decode(),
10450 }
10451 }
10452 8 => {
10453 let ans = unsafe { self.kind.LnUrlAuth };
10454 crate::bindings::InputType::LnUrlAuth {
10455 data: ans.data.cst_decode(),
10456 }
10457 }
10458 9 => {
10459 let ans = unsafe { self.kind.LnUrlError };
10460 crate::bindings::InputType::LnUrlError {
10461 data: ans.data.cst_decode(),
10462 }
10463 }
10464 _ => unreachable!(),
10465 }
10466 }
10467 }
10468 impl CstDecode<crate::model::LightningPaymentLimitsResponse>
10469 for wire_cst_lightning_payment_limits_response
10470 {
10471 fn cst_decode(self) -> crate::model::LightningPaymentLimitsResponse {
10473 crate::model::LightningPaymentLimitsResponse {
10474 send: self.send.cst_decode(),
10475 receive: self.receive.cst_decode(),
10476 }
10477 }
10478 }
10479 impl CstDecode<crate::model::Limits> for wire_cst_limits {
10480 fn cst_decode(self) -> crate::model::Limits {
10482 crate::model::Limits {
10483 min_sat: self.min_sat.cst_decode(),
10484 max_sat: self.max_sat.cst_decode(),
10485 max_zero_conf_sat: self.max_zero_conf_sat.cst_decode(),
10486 }
10487 }
10488 }
10489 impl CstDecode<crate::bindings::LiquidAddressData> for wire_cst_liquid_address_data {
10490 fn cst_decode(self) -> crate::bindings::LiquidAddressData {
10492 crate::bindings::LiquidAddressData {
10493 address: self.address.cst_decode(),
10494 network: self.network.cst_decode(),
10495 asset_id: self.asset_id.cst_decode(),
10496 amount: self.amount.cst_decode(),
10497 amount_sat: self.amount_sat.cst_decode(),
10498 label: self.label.cst_decode(),
10499 message: self.message.cst_decode(),
10500 }
10501 }
10502 }
10503 impl CstDecode<Vec<String>> for *mut wire_cst_list_String {
10504 fn cst_decode(self) -> Vec<String> {
10506 let vec = unsafe {
10507 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10508 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10509 };
10510 vec.into_iter().map(CstDecode::cst_decode).collect()
10511 }
10512 }
10513 impl CstDecode<Vec<crate::model::AssetBalance>> for *mut wire_cst_list_asset_balance {
10514 fn cst_decode(self) -> Vec<crate::model::AssetBalance> {
10516 let vec = unsafe {
10517 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10518 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10519 };
10520 vec.into_iter().map(CstDecode::cst_decode).collect()
10521 }
10522 }
10523 impl CstDecode<Vec<crate::model::AssetMetadata>> for *mut wire_cst_list_asset_metadata {
10524 fn cst_decode(self) -> Vec<crate::model::AssetMetadata> {
10526 let vec = unsafe {
10527 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10528 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10529 };
10530 vec.into_iter().map(CstDecode::cst_decode).collect()
10531 }
10532 }
10533 impl CstDecode<Vec<crate::bindings::ExternalInputParser>>
10534 for *mut wire_cst_list_external_input_parser
10535 {
10536 fn cst_decode(self) -> Vec<crate::bindings::ExternalInputParser> {
10538 let vec = unsafe {
10539 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10540 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10541 };
10542 vec.into_iter().map(CstDecode::cst_decode).collect()
10543 }
10544 }
10545 impl CstDecode<Vec<crate::bindings::FiatCurrency>> for *mut wire_cst_list_fiat_currency {
10546 fn cst_decode(self) -> Vec<crate::bindings::FiatCurrency> {
10548 let vec = unsafe {
10549 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10550 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10551 };
10552 vec.into_iter().map(CstDecode::cst_decode).collect()
10553 }
10554 }
10555 impl CstDecode<Vec<crate::bindings::LnOfferBlindedPath>>
10556 for *mut wire_cst_list_ln_offer_blinded_path
10557 {
10558 fn cst_decode(self) -> Vec<crate::bindings::LnOfferBlindedPath> {
10560 let vec = unsafe {
10561 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10562 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10563 };
10564 vec.into_iter().map(CstDecode::cst_decode).collect()
10565 }
10566 }
10567 impl CstDecode<Vec<crate::bindings::LocaleOverrides>> for *mut wire_cst_list_locale_overrides {
10568 fn cst_decode(self) -> Vec<crate::bindings::LocaleOverrides> {
10570 let vec = unsafe {
10571 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10572 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10573 };
10574 vec.into_iter().map(CstDecode::cst_decode).collect()
10575 }
10576 }
10577 impl CstDecode<Vec<crate::bindings::LocalizedName>> for *mut wire_cst_list_localized_name {
10578 fn cst_decode(self) -> Vec<crate::bindings::LocalizedName> {
10580 let vec = unsafe {
10581 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10582 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10583 };
10584 vec.into_iter().map(CstDecode::cst_decode).collect()
10585 }
10586 }
10587 impl CstDecode<Vec<crate::model::Payment>> for *mut wire_cst_list_payment {
10588 fn cst_decode(self) -> Vec<crate::model::Payment> {
10590 let vec = unsafe {
10591 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10592 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10593 };
10594 vec.into_iter().map(CstDecode::cst_decode).collect()
10595 }
10596 }
10597 impl CstDecode<crate::model::ListPaymentDetails> for wire_cst_list_payment_details {
10598 fn cst_decode(self) -> crate::model::ListPaymentDetails {
10600 match self.tag {
10601 0 => {
10602 let ans = unsafe { self.kind.Liquid };
10603 crate::model::ListPaymentDetails::Liquid {
10604 asset_id: ans.asset_id.cst_decode(),
10605 destination: ans.destination.cst_decode(),
10606 }
10607 }
10608 1 => {
10609 let ans = unsafe { self.kind.Bitcoin };
10610 crate::model::ListPaymentDetails::Bitcoin {
10611 address: ans.address.cst_decode(),
10612 }
10613 }
10614 _ => unreachable!(),
10615 }
10616 }
10617 }
10618 impl CstDecode<Vec<crate::model::PaymentState>> for *mut wire_cst_list_payment_state {
10619 fn cst_decode(self) -> Vec<crate::model::PaymentState> {
10621 let vec = unsafe {
10622 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10623 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10624 };
10625 vec.into_iter().map(CstDecode::cst_decode).collect()
10626 }
10627 }
10628 impl CstDecode<Vec<crate::model::PaymentType>> for *mut wire_cst_list_payment_type {
10629 fn cst_decode(self) -> Vec<crate::model::PaymentType> {
10631 let vec = unsafe {
10632 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10633 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10634 };
10635 vec.into_iter().map(CstDecode::cst_decode).collect()
10636 }
10637 }
10638 impl CstDecode<crate::model::ListPaymentsRequest> for wire_cst_list_payments_request {
10639 fn cst_decode(self) -> crate::model::ListPaymentsRequest {
10641 crate::model::ListPaymentsRequest {
10642 filters: self.filters.cst_decode(),
10643 states: self.states.cst_decode(),
10644 from_timestamp: self.from_timestamp.cst_decode(),
10645 to_timestamp: self.to_timestamp.cst_decode(),
10646 offset: self.offset.cst_decode(),
10647 limit: self.limit.cst_decode(),
10648 details: self.details.cst_decode(),
10649 sort_ascending: self.sort_ascending.cst_decode(),
10650 }
10651 }
10652 }
10653 impl CstDecode<Vec<u8>> for *mut wire_cst_list_prim_u_8_strict {
10654 fn cst_decode(self) -> Vec<u8> {
10656 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 }
10661 }
10662 impl CstDecode<Vec<crate::bindings::Rate>> for *mut wire_cst_list_rate {
10663 fn cst_decode(self) -> Vec<crate::bindings::Rate> {
10665 let vec = unsafe {
10666 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10667 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10668 };
10669 vec.into_iter().map(CstDecode::cst_decode).collect()
10670 }
10671 }
10672 impl CstDecode<Vec<crate::model::RefundableSwap>> for *mut wire_cst_list_refundable_swap {
10673 fn cst_decode(self) -> Vec<crate::model::RefundableSwap> {
10675 let vec = unsafe {
10676 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10677 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10678 };
10679 vec.into_iter().map(CstDecode::cst_decode).collect()
10680 }
10681 }
10682 impl CstDecode<Vec<crate::bindings::RouteHint>> for *mut wire_cst_list_route_hint {
10683 fn cst_decode(self) -> Vec<crate::bindings::RouteHint> {
10685 let vec = unsafe {
10686 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10687 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10688 };
10689 vec.into_iter().map(CstDecode::cst_decode).collect()
10690 }
10691 }
10692 impl CstDecode<Vec<crate::bindings::RouteHintHop>> for *mut wire_cst_list_route_hint_hop {
10693 fn cst_decode(self) -> Vec<crate::bindings::RouteHintHop> {
10695 let vec = unsafe {
10696 let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10697 flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10698 };
10699 vec.into_iter().map(CstDecode::cst_decode).collect()
10700 }
10701 }
10702 impl CstDecode<crate::bindings::LNInvoice> for wire_cst_ln_invoice {
10703 fn cst_decode(self) -> crate::bindings::LNInvoice {
10705 crate::bindings::LNInvoice {
10706 bolt11: self.bolt11.cst_decode(),
10707 network: self.network.cst_decode(),
10708 payee_pubkey: self.payee_pubkey.cst_decode(),
10709 payment_hash: self.payment_hash.cst_decode(),
10710 description: self.description.cst_decode(),
10711 description_hash: self.description_hash.cst_decode(),
10712 amount_msat: self.amount_msat.cst_decode(),
10713 timestamp: self.timestamp.cst_decode(),
10714 expiry: self.expiry.cst_decode(),
10715 routing_hints: self.routing_hints.cst_decode(),
10716 payment_secret: self.payment_secret.cst_decode(),
10717 min_final_cltv_expiry_delta: self.min_final_cltv_expiry_delta.cst_decode(),
10718 }
10719 }
10720 }
10721 impl CstDecode<crate::bindings::LNOffer> for wire_cst_ln_offer {
10722 fn cst_decode(self) -> crate::bindings::LNOffer {
10724 crate::bindings::LNOffer {
10725 offer: self.offer.cst_decode(),
10726 chains: self.chains.cst_decode(),
10727 min_amount: self.min_amount.cst_decode(),
10728 description: self.description.cst_decode(),
10729 absolute_expiry: self.absolute_expiry.cst_decode(),
10730 issuer: self.issuer.cst_decode(),
10731 signing_pubkey: self.signing_pubkey.cst_decode(),
10732 paths: self.paths.cst_decode(),
10733 }
10734 }
10735 }
10736 impl CstDecode<crate::bindings::LnOfferBlindedPath> for wire_cst_ln_offer_blinded_path {
10737 fn cst_decode(self) -> crate::bindings::LnOfferBlindedPath {
10739 crate::bindings::LnOfferBlindedPath {
10740 blinded_hops: self.blinded_hops.cst_decode(),
10741 }
10742 }
10743 }
10744 impl CstDecode<crate::bindings::duplicates::LnUrlAuthError> for wire_cst_ln_url_auth_error {
10745 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlAuthError {
10747 match self.tag {
10748 0 => {
10749 let ans = unsafe { self.kind.Generic };
10750 crate::bindings::duplicates::LnUrlAuthError::Generic {
10751 err: ans.err.cst_decode(),
10752 }
10753 }
10754 1 => {
10755 let ans = unsafe { self.kind.InvalidUri };
10756 crate::bindings::duplicates::LnUrlAuthError::InvalidUri {
10757 err: ans.err.cst_decode(),
10758 }
10759 }
10760 2 => {
10761 let ans = unsafe { self.kind.ServiceConnectivity };
10762 crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
10763 err: ans.err.cst_decode(),
10764 }
10765 }
10766 _ => unreachable!(),
10767 }
10768 }
10769 }
10770 impl CstDecode<crate::bindings::LnUrlAuthRequestData> for wire_cst_ln_url_auth_request_data {
10771 fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10773 crate::bindings::LnUrlAuthRequestData {
10774 k1: self.k1.cst_decode(),
10775 action: self.action.cst_decode(),
10776 domain: self.domain.cst_decode(),
10777 url: self.url.cst_decode(),
10778 }
10779 }
10780 }
10781 impl CstDecode<crate::bindings::duplicates::LnUrlCallbackStatus>
10782 for wire_cst_ln_url_callback_status
10783 {
10784 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
10786 match self.tag {
10787 0 => crate::bindings::duplicates::LnUrlCallbackStatus::Ok,
10788 1 => {
10789 let ans = unsafe { self.kind.ErrorStatus };
10790 crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
10791 data: ans.data.cst_decode(),
10792 }
10793 }
10794 _ => unreachable!(),
10795 }
10796 }
10797 }
10798 impl CstDecode<crate::bindings::LnUrlErrorData> for wire_cst_ln_url_error_data {
10799 fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10801 crate::bindings::LnUrlErrorData {
10802 reason: self.reason.cst_decode(),
10803 }
10804 }
10805 }
10806 impl CstDecode<crate::model::LnUrlInfo> for wire_cst_ln_url_info {
10807 fn cst_decode(self) -> crate::model::LnUrlInfo {
10809 crate::model::LnUrlInfo {
10810 ln_address: self.ln_address.cst_decode(),
10811 lnurl_pay_comment: self.lnurl_pay_comment.cst_decode(),
10812 lnurl_pay_domain: self.lnurl_pay_domain.cst_decode(),
10813 lnurl_pay_metadata: self.lnurl_pay_metadata.cst_decode(),
10814 lnurl_pay_success_action: self.lnurl_pay_success_action.cst_decode(),
10815 lnurl_pay_unprocessed_success_action: self
10816 .lnurl_pay_unprocessed_success_action
10817 .cst_decode(),
10818 lnurl_withdraw_endpoint: self.lnurl_withdraw_endpoint.cst_decode(),
10819 }
10820 }
10821 }
10822 impl CstDecode<crate::bindings::duplicates::LnUrlPayError> for wire_cst_ln_url_pay_error {
10823 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlPayError {
10825 match self.tag {
10826 0 => crate::bindings::duplicates::LnUrlPayError::AlreadyPaid,
10827 1 => {
10828 let ans = unsafe { self.kind.Generic };
10829 crate::bindings::duplicates::LnUrlPayError::Generic {
10830 err: ans.err.cst_decode(),
10831 }
10832 }
10833 2 => {
10834 let ans = unsafe { self.kind.InsufficientBalance };
10835 crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
10836 err: ans.err.cst_decode(),
10837 }
10838 }
10839 3 => {
10840 let ans = unsafe { self.kind.InvalidAmount };
10841 crate::bindings::duplicates::LnUrlPayError::InvalidAmount {
10842 err: ans.err.cst_decode(),
10843 }
10844 }
10845 4 => {
10846 let ans = unsafe { self.kind.InvalidInvoice };
10847 crate::bindings::duplicates::LnUrlPayError::InvalidInvoice {
10848 err: ans.err.cst_decode(),
10849 }
10850 }
10851 5 => {
10852 let ans = unsafe { self.kind.InvalidNetwork };
10853 crate::bindings::duplicates::LnUrlPayError::InvalidNetwork {
10854 err: ans.err.cst_decode(),
10855 }
10856 }
10857 6 => {
10858 let ans = unsafe { self.kind.InvalidUri };
10859 crate::bindings::duplicates::LnUrlPayError::InvalidUri {
10860 err: ans.err.cst_decode(),
10861 }
10862 }
10863 7 => {
10864 let ans = unsafe { self.kind.InvoiceExpired };
10865 crate::bindings::duplicates::LnUrlPayError::InvoiceExpired {
10866 err: ans.err.cst_decode(),
10867 }
10868 }
10869 8 => {
10870 let ans = unsafe { self.kind.PaymentFailed };
10871 crate::bindings::duplicates::LnUrlPayError::PaymentFailed {
10872 err: ans.err.cst_decode(),
10873 }
10874 }
10875 9 => {
10876 let ans = unsafe { self.kind.PaymentTimeout };
10877 crate::bindings::duplicates::LnUrlPayError::PaymentTimeout {
10878 err: ans.err.cst_decode(),
10879 }
10880 }
10881 10 => {
10882 let ans = unsafe { self.kind.RouteNotFound };
10883 crate::bindings::duplicates::LnUrlPayError::RouteNotFound {
10884 err: ans.err.cst_decode(),
10885 }
10886 }
10887 11 => {
10888 let ans = unsafe { self.kind.RouteTooExpensive };
10889 crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
10890 err: ans.err.cst_decode(),
10891 }
10892 }
10893 12 => {
10894 let ans = unsafe { self.kind.ServiceConnectivity };
10895 crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
10896 err: ans.err.cst_decode(),
10897 }
10898 }
10899 _ => unreachable!(),
10900 }
10901 }
10902 }
10903 impl CstDecode<crate::bindings::LnUrlPayErrorData> for wire_cst_ln_url_pay_error_data {
10904 fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10906 crate::bindings::LnUrlPayErrorData {
10907 payment_hash: self.payment_hash.cst_decode(),
10908 reason: self.reason.cst_decode(),
10909 }
10910 }
10911 }
10912 impl CstDecode<crate::model::LnUrlPayRequest> for wire_cst_ln_url_pay_request {
10913 fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10915 crate::model::LnUrlPayRequest {
10916 prepare_response: self.prepare_response.cst_decode(),
10917 }
10918 }
10919 }
10920 impl CstDecode<crate::bindings::LnUrlPayRequestData> for wire_cst_ln_url_pay_request_data {
10921 fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10923 crate::bindings::LnUrlPayRequestData {
10924 callback: self.callback.cst_decode(),
10925 min_sendable: self.min_sendable.cst_decode(),
10926 max_sendable: self.max_sendable.cst_decode(),
10927 metadata_str: self.metadata_str.cst_decode(),
10928 comment_allowed: self.comment_allowed.cst_decode(),
10929 domain: self.domain.cst_decode(),
10930 allows_nostr: self.allows_nostr.cst_decode(),
10931 nostr_pubkey: self.nostr_pubkey.cst_decode(),
10932 ln_address: self.ln_address.cst_decode(),
10933 }
10934 }
10935 }
10936 impl CstDecode<crate::model::LnUrlPayResult> for wire_cst_ln_url_pay_result {
10937 fn cst_decode(self) -> crate::model::LnUrlPayResult {
10939 match self.tag {
10940 0 => {
10941 let ans = unsafe { self.kind.EndpointSuccess };
10942 crate::model::LnUrlPayResult::EndpointSuccess {
10943 data: ans.data.cst_decode(),
10944 }
10945 }
10946 1 => {
10947 let ans = unsafe { self.kind.EndpointError };
10948 crate::model::LnUrlPayResult::EndpointError {
10949 data: ans.data.cst_decode(),
10950 }
10951 }
10952 2 => {
10953 let ans = unsafe { self.kind.PayError };
10954 crate::model::LnUrlPayResult::PayError {
10955 data: ans.data.cst_decode(),
10956 }
10957 }
10958 _ => unreachable!(),
10959 }
10960 }
10961 }
10962 impl CstDecode<crate::model::LnUrlPaySuccessData> for wire_cst_ln_url_pay_success_data {
10963 fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10965 crate::model::LnUrlPaySuccessData {
10966 payment: self.payment.cst_decode(),
10967 success_action: self.success_action.cst_decode(),
10968 }
10969 }
10970 }
10971 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawError> for wire_cst_ln_url_withdraw_error {
10972 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
10974 match self.tag {
10975 0 => {
10976 let ans = unsafe { self.kind.Generic };
10977 crate::bindings::duplicates::LnUrlWithdrawError::Generic {
10978 err: ans.err.cst_decode(),
10979 }
10980 }
10981 1 => {
10982 let ans = unsafe { self.kind.InvalidAmount };
10983 crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
10984 err: ans.err.cst_decode(),
10985 }
10986 }
10987 2 => {
10988 let ans = unsafe { self.kind.InvalidInvoice };
10989 crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
10990 err: ans.err.cst_decode(),
10991 }
10992 }
10993 3 => {
10994 let ans = unsafe { self.kind.InvalidUri };
10995 crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
10996 err: ans.err.cst_decode(),
10997 }
10998 }
10999 4 => {
11000 let ans = unsafe { self.kind.InvoiceNoRoutingHints };
11001 crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
11002 err: ans.err.cst_decode(),
11003 }
11004 }
11005 5 => {
11006 let ans = unsafe { self.kind.ServiceConnectivity };
11007 crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
11008 err: ans.err.cst_decode(),
11009 }
11010 }
11011 _ => unreachable!(),
11012 }
11013 }
11014 }
11015 impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for wire_cst_ln_url_withdraw_request {
11016 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
11018 crate::bindings::LnUrlWithdrawRequest {
11019 data: self.data.cst_decode(),
11020 amount_msat: self.amount_msat.cst_decode(),
11021 description: self.description.cst_decode(),
11022 }
11023 }
11024 }
11025 impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
11026 for wire_cst_ln_url_withdraw_request_data
11027 {
11028 fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
11030 crate::bindings::LnUrlWithdrawRequestData {
11031 callback: self.callback.cst_decode(),
11032 k1: self.k1.cst_decode(),
11033 default_description: self.default_description.cst_decode(),
11034 min_withdrawable: self.min_withdrawable.cst_decode(),
11035 max_withdrawable: self.max_withdrawable.cst_decode(),
11036 }
11037 }
11038 }
11039 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawResult>
11040 for wire_cst_ln_url_withdraw_result
11041 {
11042 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
11044 match self.tag {
11045 0 => {
11046 let ans = unsafe { self.kind.Ok };
11047 crate::bindings::duplicates::LnUrlWithdrawResult::Ok {
11048 data: ans.data.cst_decode(),
11049 }
11050 }
11051 1 => {
11052 let ans = unsafe { self.kind.Timeout };
11053 crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
11054 data: ans.data.cst_decode(),
11055 }
11056 }
11057 2 => {
11058 let ans = unsafe { self.kind.ErrorStatus };
11059 crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
11060 data: ans.data.cst_decode(),
11061 }
11062 }
11063 _ => unreachable!(),
11064 }
11065 }
11066 }
11067 impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
11068 for wire_cst_ln_url_withdraw_success_data
11069 {
11070 fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11072 crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11073 invoice: self.invoice.cst_decode(),
11074 }
11075 }
11076 }
11077 impl CstDecode<crate::bindings::LocaleOverrides> for wire_cst_locale_overrides {
11078 fn cst_decode(self) -> crate::bindings::LocaleOverrides {
11080 crate::bindings::LocaleOverrides {
11081 locale: self.locale.cst_decode(),
11082 spacing: self.spacing.cst_decode(),
11083 symbol: self.symbol.cst_decode(),
11084 }
11085 }
11086 }
11087 impl CstDecode<crate::bindings::LocalizedName> for wire_cst_localized_name {
11088 fn cst_decode(self) -> crate::bindings::LocalizedName {
11090 crate::bindings::LocalizedName {
11091 locale: self.locale.cst_decode(),
11092 name: self.name.cst_decode(),
11093 }
11094 }
11095 }
11096 impl CstDecode<crate::model::LogEntry> for wire_cst_log_entry {
11097 fn cst_decode(self) -> crate::model::LogEntry {
11099 crate::model::LogEntry {
11100 line: self.line.cst_decode(),
11101 level: self.level.cst_decode(),
11102 }
11103 }
11104 }
11105 impl CstDecode<crate::bindings::MessageSuccessActionData> for wire_cst_message_success_action_data {
11106 fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
11108 crate::bindings::MessageSuccessActionData {
11109 message: self.message.cst_decode(),
11110 }
11111 }
11112 }
11113 impl CstDecode<crate::model::OnchainPaymentLimitsResponse>
11114 for wire_cst_onchain_payment_limits_response
11115 {
11116 fn cst_decode(self) -> crate::model::OnchainPaymentLimitsResponse {
11118 crate::model::OnchainPaymentLimitsResponse {
11119 send: self.send.cst_decode(),
11120 receive: self.receive.cst_decode(),
11121 }
11122 }
11123 }
11124 impl CstDecode<crate::model::PayAmount> for wire_cst_pay_amount {
11125 fn cst_decode(self) -> crate::model::PayAmount {
11127 match self.tag {
11128 0 => {
11129 let ans = unsafe { self.kind.Bitcoin };
11130 crate::model::PayAmount::Bitcoin {
11131 receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11132 }
11133 }
11134 1 => {
11135 let ans = unsafe { self.kind.Asset };
11136 crate::model::PayAmount::Asset {
11137 asset_id: ans.asset_id.cst_decode(),
11138 receiver_amount: ans.receiver_amount.cst_decode(),
11139 estimate_asset_fees: ans.estimate_asset_fees.cst_decode(),
11140 }
11141 }
11142 2 => crate::model::PayAmount::Drain,
11143 _ => unreachable!(),
11144 }
11145 }
11146 }
11147 impl CstDecode<crate::model::PayOnchainRequest> for wire_cst_pay_onchain_request {
11148 fn cst_decode(self) -> crate::model::PayOnchainRequest {
11150 crate::model::PayOnchainRequest {
11151 address: self.address.cst_decode(),
11152 prepare_response: self.prepare_response.cst_decode(),
11153 }
11154 }
11155 }
11156 impl CstDecode<crate::model::Payment> for wire_cst_payment {
11157 fn cst_decode(self) -> crate::model::Payment {
11159 crate::model::Payment {
11160 destination: self.destination.cst_decode(),
11161 tx_id: self.tx_id.cst_decode(),
11162 unblinding_data: self.unblinding_data.cst_decode(),
11163 timestamp: self.timestamp.cst_decode(),
11164 amount_sat: self.amount_sat.cst_decode(),
11165 fees_sat: self.fees_sat.cst_decode(),
11166 swapper_fees_sat: self.swapper_fees_sat.cst_decode(),
11167 payment_type: self.payment_type.cst_decode(),
11168 status: self.status.cst_decode(),
11169 details: self.details.cst_decode(),
11170 }
11171 }
11172 }
11173 impl CstDecode<crate::model::PaymentDetails> for wire_cst_payment_details {
11174 fn cst_decode(self) -> crate::model::PaymentDetails {
11176 match self.tag {
11177 0 => {
11178 let ans = unsafe { self.kind.Lightning };
11179 crate::model::PaymentDetails::Lightning {
11180 swap_id: ans.swap_id.cst_decode(),
11181 description: ans.description.cst_decode(),
11182 liquid_expiration_blockheight: ans
11183 .liquid_expiration_blockheight
11184 .cst_decode(),
11185 preimage: ans.preimage.cst_decode(),
11186 invoice: ans.invoice.cst_decode(),
11187 bolt12_offer: ans.bolt12_offer.cst_decode(),
11188 payment_hash: ans.payment_hash.cst_decode(),
11189 destination_pubkey: ans.destination_pubkey.cst_decode(),
11190 lnurl_info: ans.lnurl_info.cst_decode(),
11191 bip353_address: ans.bip353_address.cst_decode(),
11192 payer_note: ans.payer_note.cst_decode(),
11193 claim_tx_id: ans.claim_tx_id.cst_decode(),
11194 refund_tx_id: ans.refund_tx_id.cst_decode(),
11195 refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11196 }
11197 }
11198 1 => {
11199 let ans = unsafe { self.kind.Liquid };
11200 crate::model::PaymentDetails::Liquid {
11201 destination: ans.destination.cst_decode(),
11202 description: ans.description.cst_decode(),
11203 asset_id: ans.asset_id.cst_decode(),
11204 asset_info: ans.asset_info.cst_decode(),
11205 lnurl_info: ans.lnurl_info.cst_decode(),
11206 bip353_address: ans.bip353_address.cst_decode(),
11207 payer_note: ans.payer_note.cst_decode(),
11208 }
11209 }
11210 2 => {
11211 let ans = unsafe { self.kind.Bitcoin };
11212 crate::model::PaymentDetails::Bitcoin {
11213 swap_id: ans.swap_id.cst_decode(),
11214 bitcoin_address: ans.bitcoin_address.cst_decode(),
11215 description: ans.description.cst_decode(),
11216 auto_accepted_fees: ans.auto_accepted_fees.cst_decode(),
11217 liquid_expiration_blockheight: ans
11218 .liquid_expiration_blockheight
11219 .cst_decode(),
11220 bitcoin_expiration_blockheight: ans
11221 .bitcoin_expiration_blockheight
11222 .cst_decode(),
11223 lockup_tx_id: ans.lockup_tx_id.cst_decode(),
11224 claim_tx_id: ans.claim_tx_id.cst_decode(),
11225 refund_tx_id: ans.refund_tx_id.cst_decode(),
11226 refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11227 }
11228 }
11229 _ => unreachable!(),
11230 }
11231 }
11232 }
11233 impl CstDecode<crate::error::PaymentError> for wire_cst_payment_error {
11234 fn cst_decode(self) -> crate::error::PaymentError {
11236 match self.tag {
11237 0 => crate::error::PaymentError::AlreadyClaimed,
11238 1 => crate::error::PaymentError::AlreadyPaid,
11239 2 => crate::error::PaymentError::PaymentInProgress,
11240 3 => {
11241 let ans = unsafe { self.kind.AmountOutOfRange };
11242 crate::error::PaymentError::AmountOutOfRange {
11243 min: ans.min.cst_decode(),
11244 max: ans.max.cst_decode(),
11245 }
11246 }
11247 4 => {
11248 let ans = unsafe { self.kind.AmountMissing };
11249 crate::error::PaymentError::AmountMissing {
11250 err: ans.err.cst_decode(),
11251 }
11252 }
11253 5 => {
11254 let ans = unsafe { self.kind.AssetError };
11255 crate::error::PaymentError::AssetError {
11256 err: ans.err.cst_decode(),
11257 }
11258 }
11259 6 => {
11260 let ans = unsafe { self.kind.InvalidNetwork };
11261 crate::error::PaymentError::InvalidNetwork {
11262 err: ans.err.cst_decode(),
11263 }
11264 }
11265 7 => {
11266 let ans = unsafe { self.kind.Generic };
11267 crate::error::PaymentError::Generic {
11268 err: ans.err.cst_decode(),
11269 }
11270 }
11271 8 => crate::error::PaymentError::InvalidOrExpiredFees,
11272 9 => crate::error::PaymentError::InsufficientFunds,
11273 10 => {
11274 let ans = unsafe { self.kind.InvalidDescription };
11275 crate::error::PaymentError::InvalidDescription {
11276 err: ans.err.cst_decode(),
11277 }
11278 }
11279 11 => {
11280 let ans = unsafe { self.kind.InvalidInvoice };
11281 crate::error::PaymentError::InvalidInvoice {
11282 err: ans.err.cst_decode(),
11283 }
11284 }
11285 12 => crate::error::PaymentError::InvalidPreimage,
11286 13 => crate::error::PaymentError::PairsNotFound,
11287 14 => crate::error::PaymentError::PaymentTimeout,
11288 15 => crate::error::PaymentError::PersistError,
11289 16 => {
11290 let ans = unsafe { self.kind.ReceiveError };
11291 crate::error::PaymentError::ReceiveError {
11292 err: ans.err.cst_decode(),
11293 }
11294 }
11295 17 => {
11296 let ans = unsafe { self.kind.Refunded };
11297 crate::error::PaymentError::Refunded {
11298 err: ans.err.cst_decode(),
11299 refund_tx_id: ans.refund_tx_id.cst_decode(),
11300 }
11301 }
11302 18 => crate::error::PaymentError::SelfTransferNotSupported,
11303 19 => {
11304 let ans = unsafe { self.kind.SendError };
11305 crate::error::PaymentError::SendError {
11306 err: ans.err.cst_decode(),
11307 }
11308 }
11309 20 => {
11310 let ans = unsafe { self.kind.SignerError };
11311 crate::error::PaymentError::SignerError {
11312 err: ans.err.cst_decode(),
11313 }
11314 }
11315 _ => unreachable!(),
11316 }
11317 }
11318 }
11319 impl CstDecode<crate::model::PrepareBuyBitcoinRequest> for wire_cst_prepare_buy_bitcoin_request {
11320 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
11322 crate::model::PrepareBuyBitcoinRequest {
11323 provider: self.provider.cst_decode(),
11324 amount_sat: self.amount_sat.cst_decode(),
11325 }
11326 }
11327 }
11328 impl CstDecode<crate::model::PrepareBuyBitcoinResponse> for wire_cst_prepare_buy_bitcoin_response {
11329 fn cst_decode(self) -> crate::model::PrepareBuyBitcoinResponse {
11331 crate::model::PrepareBuyBitcoinResponse {
11332 provider: self.provider.cst_decode(),
11333 amount_sat: self.amount_sat.cst_decode(),
11334 fees_sat: self.fees_sat.cst_decode(),
11335 }
11336 }
11337 }
11338 impl CstDecode<crate::model::PrepareLnUrlPayRequest> for wire_cst_prepare_ln_url_pay_request {
11339 fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
11341 crate::model::PrepareLnUrlPayRequest {
11342 data: self.data.cst_decode(),
11343 amount: self.amount.cst_decode(),
11344 bip353_address: self.bip353_address.cst_decode(),
11345 comment: self.comment.cst_decode(),
11346 validate_success_action_url: self.validate_success_action_url.cst_decode(),
11347 }
11348 }
11349 }
11350 impl CstDecode<crate::model::PrepareLnUrlPayResponse> for wire_cst_prepare_ln_url_pay_response {
11351 fn cst_decode(self) -> crate::model::PrepareLnUrlPayResponse {
11353 crate::model::PrepareLnUrlPayResponse {
11354 destination: self.destination.cst_decode(),
11355 fees_sat: self.fees_sat.cst_decode(),
11356 data: self.data.cst_decode(),
11357 amount: self.amount.cst_decode(),
11358 comment: self.comment.cst_decode(),
11359 success_action: self.success_action.cst_decode(),
11360 }
11361 }
11362 }
11363 impl CstDecode<crate::model::PreparePayOnchainRequest> for wire_cst_prepare_pay_onchain_request {
11364 fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
11366 crate::model::PreparePayOnchainRequest {
11367 amount: self.amount.cst_decode(),
11368 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11369 }
11370 }
11371 }
11372 impl CstDecode<crate::model::PreparePayOnchainResponse> for wire_cst_prepare_pay_onchain_response {
11373 fn cst_decode(self) -> crate::model::PreparePayOnchainResponse {
11375 crate::model::PreparePayOnchainResponse {
11376 receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
11377 claim_fees_sat: self.claim_fees_sat.cst_decode(),
11378 total_fees_sat: self.total_fees_sat.cst_decode(),
11379 }
11380 }
11381 }
11382 impl CstDecode<crate::model::PrepareReceiveRequest> for wire_cst_prepare_receive_request {
11383 fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
11385 crate::model::PrepareReceiveRequest {
11386 payment_method: self.payment_method.cst_decode(),
11387 amount: self.amount.cst_decode(),
11388 }
11389 }
11390 }
11391 impl CstDecode<crate::model::PrepareReceiveResponse> for wire_cst_prepare_receive_response {
11392 fn cst_decode(self) -> crate::model::PrepareReceiveResponse {
11394 crate::model::PrepareReceiveResponse {
11395 payment_method: self.payment_method.cst_decode(),
11396 fees_sat: self.fees_sat.cst_decode(),
11397 amount: self.amount.cst_decode(),
11398 min_payer_amount_sat: self.min_payer_amount_sat.cst_decode(),
11399 max_payer_amount_sat: self.max_payer_amount_sat.cst_decode(),
11400 swapper_feerate: self.swapper_feerate.cst_decode(),
11401 }
11402 }
11403 }
11404 impl CstDecode<crate::model::PrepareRefundRequest> for wire_cst_prepare_refund_request {
11405 fn cst_decode(self) -> crate::model::PrepareRefundRequest {
11407 crate::model::PrepareRefundRequest {
11408 swap_address: self.swap_address.cst_decode(),
11409 refund_address: self.refund_address.cst_decode(),
11410 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11411 }
11412 }
11413 }
11414 impl CstDecode<crate::model::PrepareRefundResponse> for wire_cst_prepare_refund_response {
11415 fn cst_decode(self) -> crate::model::PrepareRefundResponse {
11417 crate::model::PrepareRefundResponse {
11418 tx_vsize: self.tx_vsize.cst_decode(),
11419 tx_fee_sat: self.tx_fee_sat.cst_decode(),
11420 last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11421 }
11422 }
11423 }
11424 impl CstDecode<crate::model::PrepareSendRequest> for wire_cst_prepare_send_request {
11425 fn cst_decode(self) -> crate::model::PrepareSendRequest {
11427 crate::model::PrepareSendRequest {
11428 destination: self.destination.cst_decode(),
11429 amount: self.amount.cst_decode(),
11430 }
11431 }
11432 }
11433 impl CstDecode<crate::model::PrepareSendResponse> for wire_cst_prepare_send_response {
11434 fn cst_decode(self) -> crate::model::PrepareSendResponse {
11436 crate::model::PrepareSendResponse {
11437 destination: self.destination.cst_decode(),
11438 amount: self.amount.cst_decode(),
11439 fees_sat: self.fees_sat.cst_decode(),
11440 estimated_asset_fees: self.estimated_asset_fees.cst_decode(),
11441 }
11442 }
11443 }
11444 impl CstDecode<crate::bindings::Rate> for wire_cst_rate {
11445 fn cst_decode(self) -> crate::bindings::Rate {
11447 crate::bindings::Rate {
11448 coin: self.coin.cst_decode(),
11449 value: self.value.cst_decode(),
11450 }
11451 }
11452 }
11453 impl CstDecode<crate::model::ReceiveAmount> for wire_cst_receive_amount {
11454 fn cst_decode(self) -> crate::model::ReceiveAmount {
11456 match self.tag {
11457 0 => {
11458 let ans = unsafe { self.kind.Bitcoin };
11459 crate::model::ReceiveAmount::Bitcoin {
11460 payer_amount_sat: ans.payer_amount_sat.cst_decode(),
11461 }
11462 }
11463 1 => {
11464 let ans = unsafe { self.kind.Asset };
11465 crate::model::ReceiveAmount::Asset {
11466 asset_id: ans.asset_id.cst_decode(),
11467 payer_amount: ans.payer_amount.cst_decode(),
11468 }
11469 }
11470 _ => unreachable!(),
11471 }
11472 }
11473 }
11474 impl CstDecode<crate::model::ReceivePaymentRequest> for wire_cst_receive_payment_request {
11475 fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
11477 crate::model::ReceivePaymentRequest {
11478 prepare_response: self.prepare_response.cst_decode(),
11479 description: self.description.cst_decode(),
11480 use_description_hash: self.use_description_hash.cst_decode(),
11481 payer_note: self.payer_note.cst_decode(),
11482 }
11483 }
11484 }
11485 impl CstDecode<crate::model::ReceivePaymentResponse> for wire_cst_receive_payment_response {
11486 fn cst_decode(self) -> crate::model::ReceivePaymentResponse {
11488 crate::model::ReceivePaymentResponse {
11489 destination: self.destination.cst_decode(),
11490 }
11491 }
11492 }
11493 impl CstDecode<crate::model::RecommendedFees> for wire_cst_recommended_fees {
11494 fn cst_decode(self) -> crate::model::RecommendedFees {
11496 crate::model::RecommendedFees {
11497 fastest_fee: self.fastest_fee.cst_decode(),
11498 half_hour_fee: self.half_hour_fee.cst_decode(),
11499 hour_fee: self.hour_fee.cst_decode(),
11500 economy_fee: self.economy_fee.cst_decode(),
11501 minimum_fee: self.minimum_fee.cst_decode(),
11502 }
11503 }
11504 }
11505 impl CstDecode<crate::model::RefundRequest> for wire_cst_refund_request {
11506 fn cst_decode(self) -> crate::model::RefundRequest {
11508 crate::model::RefundRequest {
11509 swap_address: self.swap_address.cst_decode(),
11510 refund_address: self.refund_address.cst_decode(),
11511 fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11512 }
11513 }
11514 }
11515 impl CstDecode<crate::model::RefundResponse> for wire_cst_refund_response {
11516 fn cst_decode(self) -> crate::model::RefundResponse {
11518 crate::model::RefundResponse {
11519 refund_tx_id: self.refund_tx_id.cst_decode(),
11520 }
11521 }
11522 }
11523 impl CstDecode<crate::model::RefundableSwap> for wire_cst_refundable_swap {
11524 fn cst_decode(self) -> crate::model::RefundableSwap {
11526 crate::model::RefundableSwap {
11527 swap_address: self.swap_address.cst_decode(),
11528 timestamp: self.timestamp.cst_decode(),
11529 amount_sat: self.amount_sat.cst_decode(),
11530 last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11531 }
11532 }
11533 }
11534 impl CstDecode<crate::model::RestoreRequest> for wire_cst_restore_request {
11535 fn cst_decode(self) -> crate::model::RestoreRequest {
11537 crate::model::RestoreRequest {
11538 backup_path: self.backup_path.cst_decode(),
11539 }
11540 }
11541 }
11542 impl CstDecode<crate::bindings::RouteHint> for wire_cst_route_hint {
11543 fn cst_decode(self) -> crate::bindings::RouteHint {
11545 crate::bindings::RouteHint {
11546 hops: self.hops.cst_decode(),
11547 }
11548 }
11549 }
11550 impl CstDecode<crate::bindings::RouteHintHop> for wire_cst_route_hint_hop {
11551 fn cst_decode(self) -> crate::bindings::RouteHintHop {
11553 crate::bindings::RouteHintHop {
11554 src_node_id: self.src_node_id.cst_decode(),
11555 short_channel_id: self.short_channel_id.cst_decode(),
11556 fees_base_msat: self.fees_base_msat.cst_decode(),
11557 fees_proportional_millionths: self.fees_proportional_millionths.cst_decode(),
11558 cltv_expiry_delta: self.cltv_expiry_delta.cst_decode(),
11559 htlc_minimum_msat: self.htlc_minimum_msat.cst_decode(),
11560 htlc_maximum_msat: self.htlc_maximum_msat.cst_decode(),
11561 }
11562 }
11563 }
11564 impl CstDecode<crate::error::SdkError> for wire_cst_sdk_error {
11565 fn cst_decode(self) -> crate::error::SdkError {
11567 match self.tag {
11568 0 => crate::error::SdkError::AlreadyStarted,
11569 1 => {
11570 let ans = unsafe { self.kind.Generic };
11571 crate::error::SdkError::Generic {
11572 err: ans.err.cst_decode(),
11573 }
11574 }
11575 2 => crate::error::SdkError::NotStarted,
11576 3 => {
11577 let ans = unsafe { self.kind.ServiceConnectivity };
11578 crate::error::SdkError::ServiceConnectivity {
11579 err: ans.err.cst_decode(),
11580 }
11581 }
11582 _ => unreachable!(),
11583 }
11584 }
11585 }
11586 impl CstDecode<crate::model::SdkEvent> for wire_cst_sdk_event {
11587 fn cst_decode(self) -> crate::model::SdkEvent {
11589 match self.tag {
11590 0 => {
11591 let ans = unsafe { self.kind.PaymentFailed };
11592 crate::model::SdkEvent::PaymentFailed {
11593 details: ans.details.cst_decode(),
11594 }
11595 }
11596 1 => {
11597 let ans = unsafe { self.kind.PaymentPending };
11598 crate::model::SdkEvent::PaymentPending {
11599 details: ans.details.cst_decode(),
11600 }
11601 }
11602 2 => {
11603 let ans = unsafe { self.kind.PaymentRefundable };
11604 crate::model::SdkEvent::PaymentRefundable {
11605 details: ans.details.cst_decode(),
11606 }
11607 }
11608 3 => {
11609 let ans = unsafe { self.kind.PaymentRefunded };
11610 crate::model::SdkEvent::PaymentRefunded {
11611 details: ans.details.cst_decode(),
11612 }
11613 }
11614 4 => {
11615 let ans = unsafe { self.kind.PaymentRefundPending };
11616 crate::model::SdkEvent::PaymentRefundPending {
11617 details: ans.details.cst_decode(),
11618 }
11619 }
11620 5 => {
11621 let ans = unsafe { self.kind.PaymentSucceeded };
11622 crate::model::SdkEvent::PaymentSucceeded {
11623 details: ans.details.cst_decode(),
11624 }
11625 }
11626 6 => {
11627 let ans = unsafe { self.kind.PaymentWaitingConfirmation };
11628 crate::model::SdkEvent::PaymentWaitingConfirmation {
11629 details: ans.details.cst_decode(),
11630 }
11631 }
11632 7 => {
11633 let ans = unsafe { self.kind.PaymentWaitingFeeAcceptance };
11634 crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
11635 details: ans.details.cst_decode(),
11636 }
11637 }
11638 8 => crate::model::SdkEvent::Synced,
11639 9 => {
11640 let ans = unsafe { self.kind.DataSynced };
11641 crate::model::SdkEvent::DataSynced {
11642 did_pull_new_records: ans.did_pull_new_records.cst_decode(),
11643 }
11644 }
11645 _ => unreachable!(),
11646 }
11647 }
11648 }
11649 impl CstDecode<crate::model::SendDestination> for wire_cst_send_destination {
11650 fn cst_decode(self) -> crate::model::SendDestination {
11652 match self.tag {
11653 0 => {
11654 let ans = unsafe { self.kind.LiquidAddress };
11655 crate::model::SendDestination::LiquidAddress {
11656 address_data: ans.address_data.cst_decode(),
11657 bip353_address: ans.bip353_address.cst_decode(),
11658 }
11659 }
11660 1 => {
11661 let ans = unsafe { self.kind.Bolt11 };
11662 crate::model::SendDestination::Bolt11 {
11663 invoice: ans.invoice.cst_decode(),
11664 bip353_address: ans.bip353_address.cst_decode(),
11665 }
11666 }
11667 2 => {
11668 let ans = unsafe { self.kind.Bolt12 };
11669 crate::model::SendDestination::Bolt12 {
11670 offer: ans.offer.cst_decode(),
11671 receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11672 bip353_address: ans.bip353_address.cst_decode(),
11673 }
11674 }
11675 _ => unreachable!(),
11676 }
11677 }
11678 }
11679 impl CstDecode<crate::model::SendPaymentRequest> for wire_cst_send_payment_request {
11680 fn cst_decode(self) -> crate::model::SendPaymentRequest {
11682 crate::model::SendPaymentRequest {
11683 prepare_response: self.prepare_response.cst_decode(),
11684 use_asset_fees: self.use_asset_fees.cst_decode(),
11685 payer_note: self.payer_note.cst_decode(),
11686 }
11687 }
11688 }
11689 impl CstDecode<crate::model::SendPaymentResponse> for wire_cst_send_payment_response {
11690 fn cst_decode(self) -> crate::model::SendPaymentResponse {
11692 crate::model::SendPaymentResponse {
11693 payment: self.payment.cst_decode(),
11694 }
11695 }
11696 }
11697 impl CstDecode<crate::model::SignMessageRequest> for wire_cst_sign_message_request {
11698 fn cst_decode(self) -> crate::model::SignMessageRequest {
11700 crate::model::SignMessageRequest {
11701 message: self.message.cst_decode(),
11702 }
11703 }
11704 }
11705 impl CstDecode<crate::model::SignMessageResponse> for wire_cst_sign_message_response {
11706 fn cst_decode(self) -> crate::model::SignMessageResponse {
11708 crate::model::SignMessageResponse {
11709 signature: self.signature.cst_decode(),
11710 }
11711 }
11712 }
11713 impl CstDecode<crate::bindings::SuccessAction> for wire_cst_success_action {
11714 fn cst_decode(self) -> crate::bindings::SuccessAction {
11716 match self.tag {
11717 0 => {
11718 let ans = unsafe { self.kind.Aes };
11719 crate::bindings::SuccessAction::Aes {
11720 data: ans.data.cst_decode(),
11721 }
11722 }
11723 1 => {
11724 let ans = unsafe { self.kind.Message };
11725 crate::bindings::SuccessAction::Message {
11726 data: ans.data.cst_decode(),
11727 }
11728 }
11729 2 => {
11730 let ans = unsafe { self.kind.Url };
11731 crate::bindings::SuccessAction::Url {
11732 data: ans.data.cst_decode(),
11733 }
11734 }
11735 _ => unreachable!(),
11736 }
11737 }
11738 }
11739 impl CstDecode<crate::bindings::SuccessActionProcessed> for wire_cst_success_action_processed {
11740 fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
11742 match self.tag {
11743 0 => {
11744 let ans = unsafe { self.kind.Aes };
11745 crate::bindings::SuccessActionProcessed::Aes {
11746 result: ans.result.cst_decode(),
11747 }
11748 }
11749 1 => {
11750 let ans = unsafe { self.kind.Message };
11751 crate::bindings::SuccessActionProcessed::Message {
11752 data: ans.data.cst_decode(),
11753 }
11754 }
11755 2 => {
11756 let ans = unsafe { self.kind.Url };
11757 crate::bindings::SuccessActionProcessed::Url {
11758 data: ans.data.cst_decode(),
11759 }
11760 }
11761 _ => unreachable!(),
11762 }
11763 }
11764 }
11765 impl CstDecode<crate::bindings::Symbol> for wire_cst_symbol {
11766 fn cst_decode(self) -> crate::bindings::Symbol {
11768 crate::bindings::Symbol {
11769 grapheme: self.grapheme.cst_decode(),
11770 template: self.template.cst_decode(),
11771 rtl: self.rtl.cst_decode(),
11772 position: self.position.cst_decode(),
11773 }
11774 }
11775 }
11776 impl CstDecode<crate::bindings::UrlSuccessActionData> for wire_cst_url_success_action_data {
11777 fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
11779 crate::bindings::UrlSuccessActionData {
11780 description: self.description.cst_decode(),
11781 url: self.url.cst_decode(),
11782 matches_callback_domain: self.matches_callback_domain.cst_decode(),
11783 }
11784 }
11785 }
11786 impl CstDecode<crate::model::WalletInfo> for wire_cst_wallet_info {
11787 fn cst_decode(self) -> crate::model::WalletInfo {
11789 crate::model::WalletInfo {
11790 balance_sat: self.balance_sat.cst_decode(),
11791 pending_send_sat: self.pending_send_sat.cst_decode(),
11792 pending_receive_sat: self.pending_receive_sat.cst_decode(),
11793 fingerprint: self.fingerprint.cst_decode(),
11794 pubkey: self.pubkey.cst_decode(),
11795 asset_balances: self.asset_balances.cst_decode(),
11796 }
11797 }
11798 }
11799 impl NewWithNullPtr for wire_cst_accept_payment_proposed_fees_request {
11800 fn new_with_null_ptr() -> Self {
11801 Self {
11802 response: Default::default(),
11803 }
11804 }
11805 }
11806 impl Default for wire_cst_accept_payment_proposed_fees_request {
11807 fn default() -> Self {
11808 Self::new_with_null_ptr()
11809 }
11810 }
11811 impl NewWithNullPtr for wire_cst_aes_success_action_data {
11812 fn new_with_null_ptr() -> Self {
11813 Self {
11814 description: core::ptr::null_mut(),
11815 ciphertext: core::ptr::null_mut(),
11816 iv: core::ptr::null_mut(),
11817 }
11818 }
11819 }
11820 impl Default for wire_cst_aes_success_action_data {
11821 fn default() -> Self {
11822 Self::new_with_null_ptr()
11823 }
11824 }
11825 impl NewWithNullPtr for wire_cst_aes_success_action_data_decrypted {
11826 fn new_with_null_ptr() -> Self {
11827 Self {
11828 description: core::ptr::null_mut(),
11829 plaintext: core::ptr::null_mut(),
11830 }
11831 }
11832 }
11833 impl Default for wire_cst_aes_success_action_data_decrypted {
11834 fn default() -> Self {
11835 Self::new_with_null_ptr()
11836 }
11837 }
11838 impl NewWithNullPtr for wire_cst_aes_success_action_data_result {
11839 fn new_with_null_ptr() -> Self {
11840 Self {
11841 tag: -1,
11842 kind: AesSuccessActionDataResultKind { nil__: () },
11843 }
11844 }
11845 }
11846 impl Default for wire_cst_aes_success_action_data_result {
11847 fn default() -> Self {
11848 Self::new_with_null_ptr()
11849 }
11850 }
11851 impl NewWithNullPtr for wire_cst_amount {
11852 fn new_with_null_ptr() -> Self {
11853 Self {
11854 tag: -1,
11855 kind: AmountKind { nil__: () },
11856 }
11857 }
11858 }
11859 impl Default for wire_cst_amount {
11860 fn default() -> Self {
11861 Self::new_with_null_ptr()
11862 }
11863 }
11864 impl NewWithNullPtr for wire_cst_asset_balance {
11865 fn new_with_null_ptr() -> Self {
11866 Self {
11867 asset_id: core::ptr::null_mut(),
11868 balance_sat: Default::default(),
11869 name: core::ptr::null_mut(),
11870 ticker: core::ptr::null_mut(),
11871 balance: core::ptr::null_mut(),
11872 }
11873 }
11874 }
11875 impl Default for wire_cst_asset_balance {
11876 fn default() -> Self {
11877 Self::new_with_null_ptr()
11878 }
11879 }
11880 impl NewWithNullPtr for wire_cst_asset_info {
11881 fn new_with_null_ptr() -> Self {
11882 Self {
11883 name: core::ptr::null_mut(),
11884 ticker: core::ptr::null_mut(),
11885 amount: Default::default(),
11886 fees: core::ptr::null_mut(),
11887 }
11888 }
11889 }
11890 impl Default for wire_cst_asset_info {
11891 fn default() -> Self {
11892 Self::new_with_null_ptr()
11893 }
11894 }
11895 impl NewWithNullPtr for wire_cst_asset_metadata {
11896 fn new_with_null_ptr() -> Self {
11897 Self {
11898 asset_id: core::ptr::null_mut(),
11899 name: core::ptr::null_mut(),
11900 ticker: core::ptr::null_mut(),
11901 precision: Default::default(),
11902 fiat_id: core::ptr::null_mut(),
11903 }
11904 }
11905 }
11906 impl Default for wire_cst_asset_metadata {
11907 fn default() -> Self {
11908 Self::new_with_null_ptr()
11909 }
11910 }
11911 impl NewWithNullPtr for wire_cst_backup_request {
11912 fn new_with_null_ptr() -> Self {
11913 Self {
11914 backup_path: core::ptr::null_mut(),
11915 }
11916 }
11917 }
11918 impl Default for wire_cst_backup_request {
11919 fn default() -> Self {
11920 Self::new_with_null_ptr()
11921 }
11922 }
11923 impl NewWithNullPtr for wire_cst_binding_event_listener {
11924 fn new_with_null_ptr() -> Self {
11925 Self {
11926 stream: core::ptr::null_mut(),
11927 }
11928 }
11929 }
11930 impl Default for wire_cst_binding_event_listener {
11931 fn default() -> Self {
11932 Self::new_with_null_ptr()
11933 }
11934 }
11935 impl NewWithNullPtr for wire_cst_bitcoin_address_data {
11936 fn new_with_null_ptr() -> Self {
11937 Self {
11938 address: core::ptr::null_mut(),
11939 network: Default::default(),
11940 amount_sat: core::ptr::null_mut(),
11941 label: core::ptr::null_mut(),
11942 message: core::ptr::null_mut(),
11943 }
11944 }
11945 }
11946 impl Default for wire_cst_bitcoin_address_data {
11947 fn default() -> Self {
11948 Self::new_with_null_ptr()
11949 }
11950 }
11951 impl NewWithNullPtr for wire_cst_blockchain_explorer {
11952 fn new_with_null_ptr() -> Self {
11953 Self {
11954 tag: -1,
11955 kind: BlockchainExplorerKind { nil__: () },
11956 }
11957 }
11958 }
11959 impl Default for wire_cst_blockchain_explorer {
11960 fn default() -> Self {
11961 Self::new_with_null_ptr()
11962 }
11963 }
11964 impl NewWithNullPtr for wire_cst_blockchain_info {
11965 fn new_with_null_ptr() -> Self {
11966 Self {
11967 liquid_tip: Default::default(),
11968 bitcoin_tip: Default::default(),
11969 }
11970 }
11971 }
11972 impl Default for wire_cst_blockchain_info {
11973 fn default() -> Self {
11974 Self::new_with_null_ptr()
11975 }
11976 }
11977 impl NewWithNullPtr for wire_cst_buy_bitcoin_request {
11978 fn new_with_null_ptr() -> Self {
11979 Self {
11980 prepare_response: Default::default(),
11981 redirect_url: core::ptr::null_mut(),
11982 }
11983 }
11984 }
11985 impl Default for wire_cst_buy_bitcoin_request {
11986 fn default() -> Self {
11987 Self::new_with_null_ptr()
11988 }
11989 }
11990 impl NewWithNullPtr for wire_cst_check_message_request {
11991 fn new_with_null_ptr() -> Self {
11992 Self {
11993 message: core::ptr::null_mut(),
11994 pubkey: core::ptr::null_mut(),
11995 signature: core::ptr::null_mut(),
11996 }
11997 }
11998 }
11999 impl Default for wire_cst_check_message_request {
12000 fn default() -> Self {
12001 Self::new_with_null_ptr()
12002 }
12003 }
12004 impl NewWithNullPtr for wire_cst_check_message_response {
12005 fn new_with_null_ptr() -> Self {
12006 Self {
12007 is_valid: Default::default(),
12008 }
12009 }
12010 }
12011 impl Default for wire_cst_check_message_response {
12012 fn default() -> Self {
12013 Self::new_with_null_ptr()
12014 }
12015 }
12016 impl NewWithNullPtr for wire_cst_config {
12017 fn new_with_null_ptr() -> Self {
12018 Self {
12019 liquid_explorer: Default::default(),
12020 bitcoin_explorer: Default::default(),
12021 working_dir: core::ptr::null_mut(),
12022 network: Default::default(),
12023 payment_timeout_sec: Default::default(),
12024 sync_service_url: core::ptr::null_mut(),
12025 zero_conf_max_amount_sat: core::ptr::null_mut(),
12026 breez_api_key: core::ptr::null_mut(),
12027 external_input_parsers: core::ptr::null_mut(),
12028 use_default_external_input_parsers: Default::default(),
12029 onchain_fee_rate_leeway_sat: core::ptr::null_mut(),
12030 asset_metadata: core::ptr::null_mut(),
12031 sideswap_api_key: core::ptr::null_mut(),
12032 }
12033 }
12034 }
12035 impl Default for wire_cst_config {
12036 fn default() -> Self {
12037 Self::new_with_null_ptr()
12038 }
12039 }
12040 impl NewWithNullPtr for wire_cst_connect_request {
12041 fn new_with_null_ptr() -> Self {
12042 Self {
12043 config: Default::default(),
12044 mnemonic: core::ptr::null_mut(),
12045 passphrase: core::ptr::null_mut(),
12046 seed: core::ptr::null_mut(),
12047 }
12048 }
12049 }
12050 impl Default for wire_cst_connect_request {
12051 fn default() -> Self {
12052 Self::new_with_null_ptr()
12053 }
12054 }
12055 impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_request {
12056 fn new_with_null_ptr() -> Self {
12057 Self {
12058 offer: core::ptr::null_mut(),
12059 invoice_request: core::ptr::null_mut(),
12060 }
12061 }
12062 }
12063 impl Default for wire_cst_create_bolt_12_invoice_request {
12064 fn default() -> Self {
12065 Self::new_with_null_ptr()
12066 }
12067 }
12068 impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_response {
12069 fn new_with_null_ptr() -> Self {
12070 Self {
12071 invoice: core::ptr::null_mut(),
12072 }
12073 }
12074 }
12075 impl Default for wire_cst_create_bolt_12_invoice_response {
12076 fn default() -> Self {
12077 Self::new_with_null_ptr()
12078 }
12079 }
12080 impl NewWithNullPtr for wire_cst_currency_info {
12081 fn new_with_null_ptr() -> Self {
12082 Self {
12083 name: core::ptr::null_mut(),
12084 fraction_size: Default::default(),
12085 spacing: core::ptr::null_mut(),
12086 symbol: core::ptr::null_mut(),
12087 uniq_symbol: core::ptr::null_mut(),
12088 localized_name: core::ptr::null_mut(),
12089 locale_overrides: core::ptr::null_mut(),
12090 }
12091 }
12092 }
12093 impl Default for wire_cst_currency_info {
12094 fn default() -> Self {
12095 Self::new_with_null_ptr()
12096 }
12097 }
12098 impl NewWithNullPtr for wire_cst_external_input_parser {
12099 fn new_with_null_ptr() -> Self {
12100 Self {
12101 provider_id: core::ptr::null_mut(),
12102 input_regex: core::ptr::null_mut(),
12103 parser_url: core::ptr::null_mut(),
12104 }
12105 }
12106 }
12107 impl Default for wire_cst_external_input_parser {
12108 fn default() -> Self {
12109 Self::new_with_null_ptr()
12110 }
12111 }
12112 impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_request {
12113 fn new_with_null_ptr() -> Self {
12114 Self {
12115 swap_id: core::ptr::null_mut(),
12116 }
12117 }
12118 }
12119 impl Default for wire_cst_fetch_payment_proposed_fees_request {
12120 fn default() -> Self {
12121 Self::new_with_null_ptr()
12122 }
12123 }
12124 impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_response {
12125 fn new_with_null_ptr() -> Self {
12126 Self {
12127 swap_id: core::ptr::null_mut(),
12128 fees_sat: Default::default(),
12129 payer_amount_sat: Default::default(),
12130 receiver_amount_sat: Default::default(),
12131 }
12132 }
12133 }
12134 impl Default for wire_cst_fetch_payment_proposed_fees_response {
12135 fn default() -> Self {
12136 Self::new_with_null_ptr()
12137 }
12138 }
12139 impl NewWithNullPtr for wire_cst_fiat_currency {
12140 fn new_with_null_ptr() -> Self {
12141 Self {
12142 id: core::ptr::null_mut(),
12143 info: Default::default(),
12144 }
12145 }
12146 }
12147 impl Default for wire_cst_fiat_currency {
12148 fn default() -> Self {
12149 Self::new_with_null_ptr()
12150 }
12151 }
12152 impl NewWithNullPtr for wire_cst_get_info_response {
12153 fn new_with_null_ptr() -> Self {
12154 Self {
12155 wallet_info: Default::default(),
12156 blockchain_info: Default::default(),
12157 }
12158 }
12159 }
12160 impl Default for wire_cst_get_info_response {
12161 fn default() -> Self {
12162 Self::new_with_null_ptr()
12163 }
12164 }
12165 impl NewWithNullPtr for wire_cst_get_payment_request {
12166 fn new_with_null_ptr() -> Self {
12167 Self {
12168 tag: -1,
12169 kind: GetPaymentRequestKind { nil__: () },
12170 }
12171 }
12172 }
12173 impl Default for wire_cst_get_payment_request {
12174 fn default() -> Self {
12175 Self::new_with_null_ptr()
12176 }
12177 }
12178 impl NewWithNullPtr for wire_cst_input_type {
12179 fn new_with_null_ptr() -> Self {
12180 Self {
12181 tag: -1,
12182 kind: InputTypeKind { nil__: () },
12183 }
12184 }
12185 }
12186 impl Default for wire_cst_input_type {
12187 fn default() -> Self {
12188 Self::new_with_null_ptr()
12189 }
12190 }
12191 impl NewWithNullPtr for wire_cst_lightning_payment_limits_response {
12192 fn new_with_null_ptr() -> Self {
12193 Self {
12194 send: Default::default(),
12195 receive: Default::default(),
12196 }
12197 }
12198 }
12199 impl Default for wire_cst_lightning_payment_limits_response {
12200 fn default() -> Self {
12201 Self::new_with_null_ptr()
12202 }
12203 }
12204 impl NewWithNullPtr for wire_cst_limits {
12205 fn new_with_null_ptr() -> Self {
12206 Self {
12207 min_sat: Default::default(),
12208 max_sat: Default::default(),
12209 max_zero_conf_sat: Default::default(),
12210 }
12211 }
12212 }
12213 impl Default for wire_cst_limits {
12214 fn default() -> Self {
12215 Self::new_with_null_ptr()
12216 }
12217 }
12218 impl NewWithNullPtr for wire_cst_liquid_address_data {
12219 fn new_with_null_ptr() -> Self {
12220 Self {
12221 address: core::ptr::null_mut(),
12222 network: Default::default(),
12223 asset_id: core::ptr::null_mut(),
12224 amount: core::ptr::null_mut(),
12225 amount_sat: core::ptr::null_mut(),
12226 label: core::ptr::null_mut(),
12227 message: core::ptr::null_mut(),
12228 }
12229 }
12230 }
12231 impl Default for wire_cst_liquid_address_data {
12232 fn default() -> Self {
12233 Self::new_with_null_ptr()
12234 }
12235 }
12236 impl NewWithNullPtr for wire_cst_list_payment_details {
12237 fn new_with_null_ptr() -> Self {
12238 Self {
12239 tag: -1,
12240 kind: ListPaymentDetailsKind { nil__: () },
12241 }
12242 }
12243 }
12244 impl Default for wire_cst_list_payment_details {
12245 fn default() -> Self {
12246 Self::new_with_null_ptr()
12247 }
12248 }
12249 impl NewWithNullPtr for wire_cst_list_payments_request {
12250 fn new_with_null_ptr() -> Self {
12251 Self {
12252 filters: core::ptr::null_mut(),
12253 states: core::ptr::null_mut(),
12254 from_timestamp: core::ptr::null_mut(),
12255 to_timestamp: core::ptr::null_mut(),
12256 offset: core::ptr::null_mut(),
12257 limit: core::ptr::null_mut(),
12258 details: core::ptr::null_mut(),
12259 sort_ascending: core::ptr::null_mut(),
12260 }
12261 }
12262 }
12263 impl Default for wire_cst_list_payments_request {
12264 fn default() -> Self {
12265 Self::new_with_null_ptr()
12266 }
12267 }
12268 impl NewWithNullPtr for wire_cst_ln_invoice {
12269 fn new_with_null_ptr() -> Self {
12270 Self {
12271 bolt11: core::ptr::null_mut(),
12272 network: Default::default(),
12273 payee_pubkey: core::ptr::null_mut(),
12274 payment_hash: core::ptr::null_mut(),
12275 description: core::ptr::null_mut(),
12276 description_hash: core::ptr::null_mut(),
12277 amount_msat: core::ptr::null_mut(),
12278 timestamp: Default::default(),
12279 expiry: Default::default(),
12280 routing_hints: core::ptr::null_mut(),
12281 payment_secret: core::ptr::null_mut(),
12282 min_final_cltv_expiry_delta: Default::default(),
12283 }
12284 }
12285 }
12286 impl Default for wire_cst_ln_invoice {
12287 fn default() -> Self {
12288 Self::new_with_null_ptr()
12289 }
12290 }
12291 impl NewWithNullPtr for wire_cst_ln_offer {
12292 fn new_with_null_ptr() -> Self {
12293 Self {
12294 offer: core::ptr::null_mut(),
12295 chains: core::ptr::null_mut(),
12296 min_amount: core::ptr::null_mut(),
12297 description: core::ptr::null_mut(),
12298 absolute_expiry: core::ptr::null_mut(),
12299 issuer: core::ptr::null_mut(),
12300 signing_pubkey: core::ptr::null_mut(),
12301 paths: core::ptr::null_mut(),
12302 }
12303 }
12304 }
12305 impl Default for wire_cst_ln_offer {
12306 fn default() -> Self {
12307 Self::new_with_null_ptr()
12308 }
12309 }
12310 impl NewWithNullPtr for wire_cst_ln_offer_blinded_path {
12311 fn new_with_null_ptr() -> Self {
12312 Self {
12313 blinded_hops: core::ptr::null_mut(),
12314 }
12315 }
12316 }
12317 impl Default for wire_cst_ln_offer_blinded_path {
12318 fn default() -> Self {
12319 Self::new_with_null_ptr()
12320 }
12321 }
12322 impl NewWithNullPtr for wire_cst_ln_url_auth_error {
12323 fn new_with_null_ptr() -> Self {
12324 Self {
12325 tag: -1,
12326 kind: LnUrlAuthErrorKind { nil__: () },
12327 }
12328 }
12329 }
12330 impl Default for wire_cst_ln_url_auth_error {
12331 fn default() -> Self {
12332 Self::new_with_null_ptr()
12333 }
12334 }
12335 impl NewWithNullPtr for wire_cst_ln_url_auth_request_data {
12336 fn new_with_null_ptr() -> Self {
12337 Self {
12338 k1: core::ptr::null_mut(),
12339 action: core::ptr::null_mut(),
12340 domain: core::ptr::null_mut(),
12341 url: core::ptr::null_mut(),
12342 }
12343 }
12344 }
12345 impl Default for wire_cst_ln_url_auth_request_data {
12346 fn default() -> Self {
12347 Self::new_with_null_ptr()
12348 }
12349 }
12350 impl NewWithNullPtr for wire_cst_ln_url_callback_status {
12351 fn new_with_null_ptr() -> Self {
12352 Self {
12353 tag: -1,
12354 kind: LnUrlCallbackStatusKind { nil__: () },
12355 }
12356 }
12357 }
12358 impl Default for wire_cst_ln_url_callback_status {
12359 fn default() -> Self {
12360 Self::new_with_null_ptr()
12361 }
12362 }
12363 impl NewWithNullPtr for wire_cst_ln_url_error_data {
12364 fn new_with_null_ptr() -> Self {
12365 Self {
12366 reason: core::ptr::null_mut(),
12367 }
12368 }
12369 }
12370 impl Default for wire_cst_ln_url_error_data {
12371 fn default() -> Self {
12372 Self::new_with_null_ptr()
12373 }
12374 }
12375 impl NewWithNullPtr for wire_cst_ln_url_info {
12376 fn new_with_null_ptr() -> Self {
12377 Self {
12378 ln_address: core::ptr::null_mut(),
12379 lnurl_pay_comment: core::ptr::null_mut(),
12380 lnurl_pay_domain: core::ptr::null_mut(),
12381 lnurl_pay_metadata: core::ptr::null_mut(),
12382 lnurl_pay_success_action: core::ptr::null_mut(),
12383 lnurl_pay_unprocessed_success_action: core::ptr::null_mut(),
12384 lnurl_withdraw_endpoint: core::ptr::null_mut(),
12385 }
12386 }
12387 }
12388 impl Default for wire_cst_ln_url_info {
12389 fn default() -> Self {
12390 Self::new_with_null_ptr()
12391 }
12392 }
12393 impl NewWithNullPtr for wire_cst_ln_url_pay_error {
12394 fn new_with_null_ptr() -> Self {
12395 Self {
12396 tag: -1,
12397 kind: LnUrlPayErrorKind { nil__: () },
12398 }
12399 }
12400 }
12401 impl Default for wire_cst_ln_url_pay_error {
12402 fn default() -> Self {
12403 Self::new_with_null_ptr()
12404 }
12405 }
12406 impl NewWithNullPtr for wire_cst_ln_url_pay_error_data {
12407 fn new_with_null_ptr() -> Self {
12408 Self {
12409 payment_hash: core::ptr::null_mut(),
12410 reason: core::ptr::null_mut(),
12411 }
12412 }
12413 }
12414 impl Default for wire_cst_ln_url_pay_error_data {
12415 fn default() -> Self {
12416 Self::new_with_null_ptr()
12417 }
12418 }
12419 impl NewWithNullPtr for wire_cst_ln_url_pay_request {
12420 fn new_with_null_ptr() -> Self {
12421 Self {
12422 prepare_response: Default::default(),
12423 }
12424 }
12425 }
12426 impl Default for wire_cst_ln_url_pay_request {
12427 fn default() -> Self {
12428 Self::new_with_null_ptr()
12429 }
12430 }
12431 impl NewWithNullPtr for wire_cst_ln_url_pay_request_data {
12432 fn new_with_null_ptr() -> Self {
12433 Self {
12434 callback: core::ptr::null_mut(),
12435 min_sendable: Default::default(),
12436 max_sendable: Default::default(),
12437 metadata_str: core::ptr::null_mut(),
12438 comment_allowed: Default::default(),
12439 domain: core::ptr::null_mut(),
12440 allows_nostr: Default::default(),
12441 nostr_pubkey: core::ptr::null_mut(),
12442 ln_address: core::ptr::null_mut(),
12443 }
12444 }
12445 }
12446 impl Default for wire_cst_ln_url_pay_request_data {
12447 fn default() -> Self {
12448 Self::new_with_null_ptr()
12449 }
12450 }
12451 impl NewWithNullPtr for wire_cst_ln_url_pay_result {
12452 fn new_with_null_ptr() -> Self {
12453 Self {
12454 tag: -1,
12455 kind: LnUrlPayResultKind { nil__: () },
12456 }
12457 }
12458 }
12459 impl Default for wire_cst_ln_url_pay_result {
12460 fn default() -> Self {
12461 Self::new_with_null_ptr()
12462 }
12463 }
12464 impl NewWithNullPtr for wire_cst_ln_url_pay_success_data {
12465 fn new_with_null_ptr() -> Self {
12466 Self {
12467 payment: Default::default(),
12468 success_action: core::ptr::null_mut(),
12469 }
12470 }
12471 }
12472 impl Default for wire_cst_ln_url_pay_success_data {
12473 fn default() -> Self {
12474 Self::new_with_null_ptr()
12475 }
12476 }
12477 impl NewWithNullPtr for wire_cst_ln_url_withdraw_error {
12478 fn new_with_null_ptr() -> Self {
12479 Self {
12480 tag: -1,
12481 kind: LnUrlWithdrawErrorKind { nil__: () },
12482 }
12483 }
12484 }
12485 impl Default for wire_cst_ln_url_withdraw_error {
12486 fn default() -> Self {
12487 Self::new_with_null_ptr()
12488 }
12489 }
12490 impl NewWithNullPtr for wire_cst_ln_url_withdraw_request {
12491 fn new_with_null_ptr() -> Self {
12492 Self {
12493 data: Default::default(),
12494 amount_msat: Default::default(),
12495 description: core::ptr::null_mut(),
12496 }
12497 }
12498 }
12499 impl Default for wire_cst_ln_url_withdraw_request {
12500 fn default() -> Self {
12501 Self::new_with_null_ptr()
12502 }
12503 }
12504 impl NewWithNullPtr for wire_cst_ln_url_withdraw_request_data {
12505 fn new_with_null_ptr() -> Self {
12506 Self {
12507 callback: core::ptr::null_mut(),
12508 k1: core::ptr::null_mut(),
12509 default_description: core::ptr::null_mut(),
12510 min_withdrawable: Default::default(),
12511 max_withdrawable: Default::default(),
12512 }
12513 }
12514 }
12515 impl Default for wire_cst_ln_url_withdraw_request_data {
12516 fn default() -> Self {
12517 Self::new_with_null_ptr()
12518 }
12519 }
12520 impl NewWithNullPtr for wire_cst_ln_url_withdraw_result {
12521 fn new_with_null_ptr() -> Self {
12522 Self {
12523 tag: -1,
12524 kind: LnUrlWithdrawResultKind { nil__: () },
12525 }
12526 }
12527 }
12528 impl Default for wire_cst_ln_url_withdraw_result {
12529 fn default() -> Self {
12530 Self::new_with_null_ptr()
12531 }
12532 }
12533 impl NewWithNullPtr for wire_cst_ln_url_withdraw_success_data {
12534 fn new_with_null_ptr() -> Self {
12535 Self {
12536 invoice: Default::default(),
12537 }
12538 }
12539 }
12540 impl Default for wire_cst_ln_url_withdraw_success_data {
12541 fn default() -> Self {
12542 Self::new_with_null_ptr()
12543 }
12544 }
12545 impl NewWithNullPtr for wire_cst_locale_overrides {
12546 fn new_with_null_ptr() -> Self {
12547 Self {
12548 locale: core::ptr::null_mut(),
12549 spacing: core::ptr::null_mut(),
12550 symbol: Default::default(),
12551 }
12552 }
12553 }
12554 impl Default for wire_cst_locale_overrides {
12555 fn default() -> Self {
12556 Self::new_with_null_ptr()
12557 }
12558 }
12559 impl NewWithNullPtr for wire_cst_localized_name {
12560 fn new_with_null_ptr() -> Self {
12561 Self {
12562 locale: core::ptr::null_mut(),
12563 name: core::ptr::null_mut(),
12564 }
12565 }
12566 }
12567 impl Default for wire_cst_localized_name {
12568 fn default() -> Self {
12569 Self::new_with_null_ptr()
12570 }
12571 }
12572 impl NewWithNullPtr for wire_cst_log_entry {
12573 fn new_with_null_ptr() -> Self {
12574 Self {
12575 line: core::ptr::null_mut(),
12576 level: core::ptr::null_mut(),
12577 }
12578 }
12579 }
12580 impl Default for wire_cst_log_entry {
12581 fn default() -> Self {
12582 Self::new_with_null_ptr()
12583 }
12584 }
12585 impl NewWithNullPtr for wire_cst_message_success_action_data {
12586 fn new_with_null_ptr() -> Self {
12587 Self {
12588 message: core::ptr::null_mut(),
12589 }
12590 }
12591 }
12592 impl Default for wire_cst_message_success_action_data {
12593 fn default() -> Self {
12594 Self::new_with_null_ptr()
12595 }
12596 }
12597 impl NewWithNullPtr for wire_cst_onchain_payment_limits_response {
12598 fn new_with_null_ptr() -> Self {
12599 Self {
12600 send: Default::default(),
12601 receive: Default::default(),
12602 }
12603 }
12604 }
12605 impl Default for wire_cst_onchain_payment_limits_response {
12606 fn default() -> Self {
12607 Self::new_with_null_ptr()
12608 }
12609 }
12610 impl NewWithNullPtr for wire_cst_pay_amount {
12611 fn new_with_null_ptr() -> Self {
12612 Self {
12613 tag: -1,
12614 kind: PayAmountKind { nil__: () },
12615 }
12616 }
12617 }
12618 impl Default for wire_cst_pay_amount {
12619 fn default() -> Self {
12620 Self::new_with_null_ptr()
12621 }
12622 }
12623 impl NewWithNullPtr for wire_cst_pay_onchain_request {
12624 fn new_with_null_ptr() -> Self {
12625 Self {
12626 address: core::ptr::null_mut(),
12627 prepare_response: Default::default(),
12628 }
12629 }
12630 }
12631 impl Default for wire_cst_pay_onchain_request {
12632 fn default() -> Self {
12633 Self::new_with_null_ptr()
12634 }
12635 }
12636 impl NewWithNullPtr for wire_cst_payment {
12637 fn new_with_null_ptr() -> Self {
12638 Self {
12639 destination: core::ptr::null_mut(),
12640 tx_id: core::ptr::null_mut(),
12641 unblinding_data: core::ptr::null_mut(),
12642 timestamp: Default::default(),
12643 amount_sat: Default::default(),
12644 fees_sat: Default::default(),
12645 swapper_fees_sat: core::ptr::null_mut(),
12646 payment_type: Default::default(),
12647 status: Default::default(),
12648 details: Default::default(),
12649 }
12650 }
12651 }
12652 impl Default for wire_cst_payment {
12653 fn default() -> Self {
12654 Self::new_with_null_ptr()
12655 }
12656 }
12657 impl NewWithNullPtr for wire_cst_payment_details {
12658 fn new_with_null_ptr() -> Self {
12659 Self {
12660 tag: -1,
12661 kind: PaymentDetailsKind { nil__: () },
12662 }
12663 }
12664 }
12665 impl Default for wire_cst_payment_details {
12666 fn default() -> Self {
12667 Self::new_with_null_ptr()
12668 }
12669 }
12670 impl NewWithNullPtr for wire_cst_payment_error {
12671 fn new_with_null_ptr() -> Self {
12672 Self {
12673 tag: -1,
12674 kind: PaymentErrorKind { nil__: () },
12675 }
12676 }
12677 }
12678 impl Default for wire_cst_payment_error {
12679 fn default() -> Self {
12680 Self::new_with_null_ptr()
12681 }
12682 }
12683 impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_request {
12684 fn new_with_null_ptr() -> Self {
12685 Self {
12686 provider: Default::default(),
12687 amount_sat: Default::default(),
12688 }
12689 }
12690 }
12691 impl Default for wire_cst_prepare_buy_bitcoin_request {
12692 fn default() -> Self {
12693 Self::new_with_null_ptr()
12694 }
12695 }
12696 impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_response {
12697 fn new_with_null_ptr() -> Self {
12698 Self {
12699 provider: Default::default(),
12700 amount_sat: Default::default(),
12701 fees_sat: Default::default(),
12702 }
12703 }
12704 }
12705 impl Default for wire_cst_prepare_buy_bitcoin_response {
12706 fn default() -> Self {
12707 Self::new_with_null_ptr()
12708 }
12709 }
12710 impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_request {
12711 fn new_with_null_ptr() -> Self {
12712 Self {
12713 data: Default::default(),
12714 amount: Default::default(),
12715 bip353_address: core::ptr::null_mut(),
12716 comment: core::ptr::null_mut(),
12717 validate_success_action_url: core::ptr::null_mut(),
12718 }
12719 }
12720 }
12721 impl Default for wire_cst_prepare_ln_url_pay_request {
12722 fn default() -> Self {
12723 Self::new_with_null_ptr()
12724 }
12725 }
12726 impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_response {
12727 fn new_with_null_ptr() -> Self {
12728 Self {
12729 destination: Default::default(),
12730 fees_sat: Default::default(),
12731 data: Default::default(),
12732 amount: Default::default(),
12733 comment: core::ptr::null_mut(),
12734 success_action: core::ptr::null_mut(),
12735 }
12736 }
12737 }
12738 impl Default for wire_cst_prepare_ln_url_pay_response {
12739 fn default() -> Self {
12740 Self::new_with_null_ptr()
12741 }
12742 }
12743 impl NewWithNullPtr for wire_cst_prepare_pay_onchain_request {
12744 fn new_with_null_ptr() -> Self {
12745 Self {
12746 amount: Default::default(),
12747 fee_rate_sat_per_vbyte: core::ptr::null_mut(),
12748 }
12749 }
12750 }
12751 impl Default for wire_cst_prepare_pay_onchain_request {
12752 fn default() -> Self {
12753 Self::new_with_null_ptr()
12754 }
12755 }
12756 impl NewWithNullPtr for wire_cst_prepare_pay_onchain_response {
12757 fn new_with_null_ptr() -> Self {
12758 Self {
12759 receiver_amount_sat: Default::default(),
12760 claim_fees_sat: Default::default(),
12761 total_fees_sat: Default::default(),
12762 }
12763 }
12764 }
12765 impl Default for wire_cst_prepare_pay_onchain_response {
12766 fn default() -> Self {
12767 Self::new_with_null_ptr()
12768 }
12769 }
12770 impl NewWithNullPtr for wire_cst_prepare_receive_request {
12771 fn new_with_null_ptr() -> Self {
12772 Self {
12773 payment_method: Default::default(),
12774 amount: core::ptr::null_mut(),
12775 }
12776 }
12777 }
12778 impl Default for wire_cst_prepare_receive_request {
12779 fn default() -> Self {
12780 Self::new_with_null_ptr()
12781 }
12782 }
12783 impl NewWithNullPtr for wire_cst_prepare_receive_response {
12784 fn new_with_null_ptr() -> Self {
12785 Self {
12786 payment_method: Default::default(),
12787 fees_sat: Default::default(),
12788 amount: core::ptr::null_mut(),
12789 min_payer_amount_sat: core::ptr::null_mut(),
12790 max_payer_amount_sat: core::ptr::null_mut(),
12791 swapper_feerate: core::ptr::null_mut(),
12792 }
12793 }
12794 }
12795 impl Default for wire_cst_prepare_receive_response {
12796 fn default() -> Self {
12797 Self::new_with_null_ptr()
12798 }
12799 }
12800 impl NewWithNullPtr for wire_cst_prepare_refund_request {
12801 fn new_with_null_ptr() -> Self {
12802 Self {
12803 swap_address: core::ptr::null_mut(),
12804 refund_address: core::ptr::null_mut(),
12805 fee_rate_sat_per_vbyte: Default::default(),
12806 }
12807 }
12808 }
12809 impl Default for wire_cst_prepare_refund_request {
12810 fn default() -> Self {
12811 Self::new_with_null_ptr()
12812 }
12813 }
12814 impl NewWithNullPtr for wire_cst_prepare_refund_response {
12815 fn new_with_null_ptr() -> Self {
12816 Self {
12817 tx_vsize: Default::default(),
12818 tx_fee_sat: Default::default(),
12819 last_refund_tx_id: core::ptr::null_mut(),
12820 }
12821 }
12822 }
12823 impl Default for wire_cst_prepare_refund_response {
12824 fn default() -> Self {
12825 Self::new_with_null_ptr()
12826 }
12827 }
12828 impl NewWithNullPtr for wire_cst_prepare_send_request {
12829 fn new_with_null_ptr() -> Self {
12830 Self {
12831 destination: core::ptr::null_mut(),
12832 amount: core::ptr::null_mut(),
12833 }
12834 }
12835 }
12836 impl Default for wire_cst_prepare_send_request {
12837 fn default() -> Self {
12838 Self::new_with_null_ptr()
12839 }
12840 }
12841 impl NewWithNullPtr for wire_cst_prepare_send_response {
12842 fn new_with_null_ptr() -> Self {
12843 Self {
12844 destination: Default::default(),
12845 amount: core::ptr::null_mut(),
12846 fees_sat: core::ptr::null_mut(),
12847 estimated_asset_fees: core::ptr::null_mut(),
12848 }
12849 }
12850 }
12851 impl Default for wire_cst_prepare_send_response {
12852 fn default() -> Self {
12853 Self::new_with_null_ptr()
12854 }
12855 }
12856 impl NewWithNullPtr for wire_cst_rate {
12857 fn new_with_null_ptr() -> Self {
12858 Self {
12859 coin: core::ptr::null_mut(),
12860 value: Default::default(),
12861 }
12862 }
12863 }
12864 impl Default for wire_cst_rate {
12865 fn default() -> Self {
12866 Self::new_with_null_ptr()
12867 }
12868 }
12869 impl NewWithNullPtr for wire_cst_receive_amount {
12870 fn new_with_null_ptr() -> Self {
12871 Self {
12872 tag: -1,
12873 kind: ReceiveAmountKind { nil__: () },
12874 }
12875 }
12876 }
12877 impl Default for wire_cst_receive_amount {
12878 fn default() -> Self {
12879 Self::new_with_null_ptr()
12880 }
12881 }
12882 impl NewWithNullPtr for wire_cst_receive_payment_request {
12883 fn new_with_null_ptr() -> Self {
12884 Self {
12885 prepare_response: Default::default(),
12886 description: core::ptr::null_mut(),
12887 use_description_hash: core::ptr::null_mut(),
12888 payer_note: core::ptr::null_mut(),
12889 }
12890 }
12891 }
12892 impl Default for wire_cst_receive_payment_request {
12893 fn default() -> Self {
12894 Self::new_with_null_ptr()
12895 }
12896 }
12897 impl NewWithNullPtr for wire_cst_receive_payment_response {
12898 fn new_with_null_ptr() -> Self {
12899 Self {
12900 destination: core::ptr::null_mut(),
12901 }
12902 }
12903 }
12904 impl Default for wire_cst_receive_payment_response {
12905 fn default() -> Self {
12906 Self::new_with_null_ptr()
12907 }
12908 }
12909 impl NewWithNullPtr for wire_cst_recommended_fees {
12910 fn new_with_null_ptr() -> Self {
12911 Self {
12912 fastest_fee: Default::default(),
12913 half_hour_fee: Default::default(),
12914 hour_fee: Default::default(),
12915 economy_fee: Default::default(),
12916 minimum_fee: Default::default(),
12917 }
12918 }
12919 }
12920 impl Default for wire_cst_recommended_fees {
12921 fn default() -> Self {
12922 Self::new_with_null_ptr()
12923 }
12924 }
12925 impl NewWithNullPtr for wire_cst_refund_request {
12926 fn new_with_null_ptr() -> Self {
12927 Self {
12928 swap_address: core::ptr::null_mut(),
12929 refund_address: core::ptr::null_mut(),
12930 fee_rate_sat_per_vbyte: Default::default(),
12931 }
12932 }
12933 }
12934 impl Default for wire_cst_refund_request {
12935 fn default() -> Self {
12936 Self::new_with_null_ptr()
12937 }
12938 }
12939 impl NewWithNullPtr for wire_cst_refund_response {
12940 fn new_with_null_ptr() -> Self {
12941 Self {
12942 refund_tx_id: core::ptr::null_mut(),
12943 }
12944 }
12945 }
12946 impl Default for wire_cst_refund_response {
12947 fn default() -> Self {
12948 Self::new_with_null_ptr()
12949 }
12950 }
12951 impl NewWithNullPtr for wire_cst_refundable_swap {
12952 fn new_with_null_ptr() -> Self {
12953 Self {
12954 swap_address: core::ptr::null_mut(),
12955 timestamp: Default::default(),
12956 amount_sat: Default::default(),
12957 last_refund_tx_id: core::ptr::null_mut(),
12958 }
12959 }
12960 }
12961 impl Default for wire_cst_refundable_swap {
12962 fn default() -> Self {
12963 Self::new_with_null_ptr()
12964 }
12965 }
12966 impl NewWithNullPtr for wire_cst_restore_request {
12967 fn new_with_null_ptr() -> Self {
12968 Self {
12969 backup_path: core::ptr::null_mut(),
12970 }
12971 }
12972 }
12973 impl Default for wire_cst_restore_request {
12974 fn default() -> Self {
12975 Self::new_with_null_ptr()
12976 }
12977 }
12978 impl NewWithNullPtr for wire_cst_route_hint {
12979 fn new_with_null_ptr() -> Self {
12980 Self {
12981 hops: core::ptr::null_mut(),
12982 }
12983 }
12984 }
12985 impl Default for wire_cst_route_hint {
12986 fn default() -> Self {
12987 Self::new_with_null_ptr()
12988 }
12989 }
12990 impl NewWithNullPtr for wire_cst_route_hint_hop {
12991 fn new_with_null_ptr() -> Self {
12992 Self {
12993 src_node_id: core::ptr::null_mut(),
12994 short_channel_id: core::ptr::null_mut(),
12995 fees_base_msat: Default::default(),
12996 fees_proportional_millionths: Default::default(),
12997 cltv_expiry_delta: Default::default(),
12998 htlc_minimum_msat: core::ptr::null_mut(),
12999 htlc_maximum_msat: core::ptr::null_mut(),
13000 }
13001 }
13002 }
13003 impl Default for wire_cst_route_hint_hop {
13004 fn default() -> Self {
13005 Self::new_with_null_ptr()
13006 }
13007 }
13008 impl NewWithNullPtr for wire_cst_sdk_error {
13009 fn new_with_null_ptr() -> Self {
13010 Self {
13011 tag: -1,
13012 kind: SdkErrorKind { nil__: () },
13013 }
13014 }
13015 }
13016 impl Default for wire_cst_sdk_error {
13017 fn default() -> Self {
13018 Self::new_with_null_ptr()
13019 }
13020 }
13021 impl NewWithNullPtr for wire_cst_sdk_event {
13022 fn new_with_null_ptr() -> Self {
13023 Self {
13024 tag: -1,
13025 kind: SdkEventKind { nil__: () },
13026 }
13027 }
13028 }
13029 impl Default for wire_cst_sdk_event {
13030 fn default() -> Self {
13031 Self::new_with_null_ptr()
13032 }
13033 }
13034 impl NewWithNullPtr for wire_cst_send_destination {
13035 fn new_with_null_ptr() -> Self {
13036 Self {
13037 tag: -1,
13038 kind: SendDestinationKind { nil__: () },
13039 }
13040 }
13041 }
13042 impl Default for wire_cst_send_destination {
13043 fn default() -> Self {
13044 Self::new_with_null_ptr()
13045 }
13046 }
13047 impl NewWithNullPtr for wire_cst_send_payment_request {
13048 fn new_with_null_ptr() -> Self {
13049 Self {
13050 prepare_response: Default::default(),
13051 use_asset_fees: core::ptr::null_mut(),
13052 payer_note: core::ptr::null_mut(),
13053 }
13054 }
13055 }
13056 impl Default for wire_cst_send_payment_request {
13057 fn default() -> Self {
13058 Self::new_with_null_ptr()
13059 }
13060 }
13061 impl NewWithNullPtr for wire_cst_send_payment_response {
13062 fn new_with_null_ptr() -> Self {
13063 Self {
13064 payment: Default::default(),
13065 }
13066 }
13067 }
13068 impl Default for wire_cst_send_payment_response {
13069 fn default() -> Self {
13070 Self::new_with_null_ptr()
13071 }
13072 }
13073 impl NewWithNullPtr for wire_cst_sign_message_request {
13074 fn new_with_null_ptr() -> Self {
13075 Self {
13076 message: core::ptr::null_mut(),
13077 }
13078 }
13079 }
13080 impl Default for wire_cst_sign_message_request {
13081 fn default() -> Self {
13082 Self::new_with_null_ptr()
13083 }
13084 }
13085 impl NewWithNullPtr for wire_cst_sign_message_response {
13086 fn new_with_null_ptr() -> Self {
13087 Self {
13088 signature: core::ptr::null_mut(),
13089 }
13090 }
13091 }
13092 impl Default for wire_cst_sign_message_response {
13093 fn default() -> Self {
13094 Self::new_with_null_ptr()
13095 }
13096 }
13097 impl NewWithNullPtr for wire_cst_success_action {
13098 fn new_with_null_ptr() -> Self {
13099 Self {
13100 tag: -1,
13101 kind: SuccessActionKind { nil__: () },
13102 }
13103 }
13104 }
13105 impl Default for wire_cst_success_action {
13106 fn default() -> Self {
13107 Self::new_with_null_ptr()
13108 }
13109 }
13110 impl NewWithNullPtr for wire_cst_success_action_processed {
13111 fn new_with_null_ptr() -> Self {
13112 Self {
13113 tag: -1,
13114 kind: SuccessActionProcessedKind { nil__: () },
13115 }
13116 }
13117 }
13118 impl Default for wire_cst_success_action_processed {
13119 fn default() -> Self {
13120 Self::new_with_null_ptr()
13121 }
13122 }
13123 impl NewWithNullPtr for wire_cst_symbol {
13124 fn new_with_null_ptr() -> Self {
13125 Self {
13126 grapheme: core::ptr::null_mut(),
13127 template: core::ptr::null_mut(),
13128 rtl: core::ptr::null_mut(),
13129 position: core::ptr::null_mut(),
13130 }
13131 }
13132 }
13133 impl Default for wire_cst_symbol {
13134 fn default() -> Self {
13135 Self::new_with_null_ptr()
13136 }
13137 }
13138 impl NewWithNullPtr for wire_cst_url_success_action_data {
13139 fn new_with_null_ptr() -> Self {
13140 Self {
13141 description: core::ptr::null_mut(),
13142 url: core::ptr::null_mut(),
13143 matches_callback_domain: Default::default(),
13144 }
13145 }
13146 }
13147 impl Default for wire_cst_url_success_action_data {
13148 fn default() -> Self {
13149 Self::new_with_null_ptr()
13150 }
13151 }
13152 impl NewWithNullPtr for wire_cst_wallet_info {
13153 fn new_with_null_ptr() -> Self {
13154 Self {
13155 balance_sat: Default::default(),
13156 pending_send_sat: Default::default(),
13157 pending_receive_sat: Default::default(),
13158 fingerprint: core::ptr::null_mut(),
13159 pubkey: core::ptr::null_mut(),
13160 asset_balances: core::ptr::null_mut(),
13161 }
13162 }
13163 }
13164 impl Default for wire_cst_wallet_info {
13165 fn default() -> Self {
13166 Self::new_with_null_ptr()
13167 }
13168 }
13169
13170 #[unsafe(no_mangle)]
13171 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees(
13172 port_: i64,
13173 that: usize,
13174 req: *mut wire_cst_accept_payment_proposed_fees_request,
13175 ) {
13176 wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(port_, that, req)
13177 }
13178
13179 #[unsafe(no_mangle)]
13180 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_add_event_listener(
13181 port_: i64,
13182 that: usize,
13183 listener: *mut wire_cst_list_prim_u_8_strict,
13184 ) {
13185 wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(port_, that, listener)
13186 }
13187
13188 #[unsafe(no_mangle)]
13189 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_backup(
13190 that: usize,
13191 req: *mut wire_cst_backup_request,
13192 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13193 wire__crate__bindings__BindingLiquidSdk_backup_impl(that, req)
13194 }
13195
13196 #[unsafe(no_mangle)]
13197 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_buy_bitcoin(
13198 port_: i64,
13199 that: usize,
13200 req: *mut wire_cst_buy_bitcoin_request,
13201 ) {
13202 wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(port_, that, req)
13203 }
13204
13205 #[unsafe(no_mangle)]
13206 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_check_message(
13207 that: usize,
13208 req: *mut wire_cst_check_message_request,
13209 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13210 wire__crate__bindings__BindingLiquidSdk_check_message_impl(that, req)
13211 }
13212
13213 #[unsafe(no_mangle)]
13214 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice(
13215 port_: i64,
13216 that: usize,
13217 req: *mut wire_cst_create_bolt_12_invoice_request,
13218 ) {
13219 wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(port_, that, req)
13220 }
13221
13222 #[unsafe(no_mangle)]
13223 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_disconnect(
13224 port_: i64,
13225 that: usize,
13226 ) {
13227 wire__crate__bindings__BindingLiquidSdk_disconnect_impl(port_, that)
13228 }
13229
13230 #[unsafe(no_mangle)]
13231 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache(
13232 that: usize,
13233 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13234 wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(that)
13235 }
13236
13237 #[unsafe(no_mangle)]
13238 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates(
13239 port_: i64,
13240 that: usize,
13241 ) {
13242 wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(port_, that)
13243 }
13244
13245 #[unsafe(no_mangle)]
13246 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
13247 port_: i64,
13248 that: usize,
13249 ) {
13250 wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(port_, that)
13251 }
13252
13253 #[unsafe(no_mangle)]
13254 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
13255 port_: i64,
13256 that: usize,
13257 ) {
13258 wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(port_, that)
13259 }
13260
13261 #[unsafe(no_mangle)]
13262 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees(
13263 port_: i64,
13264 that: usize,
13265 req: *mut wire_cst_fetch_payment_proposed_fees_request,
13266 ) {
13267 wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(port_, that, req)
13268 }
13269
13270 #[unsafe(no_mangle)]
13271 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info(
13272 port_: i64,
13273 that: usize,
13274 ) {
13275 wire__crate__bindings__BindingLiquidSdk_get_info_impl(port_, that)
13276 }
13277
13278 #[unsafe(no_mangle)]
13279 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_payment(
13280 port_: i64,
13281 that: usize,
13282 req: *mut wire_cst_get_payment_request,
13283 ) {
13284 wire__crate__bindings__BindingLiquidSdk_get_payment_impl(port_, that, req)
13285 }
13286
13287 #[unsafe(no_mangle)]
13288 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies(
13289 port_: i64,
13290 that: usize,
13291 ) {
13292 wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(port_, that)
13293 }
13294
13295 #[unsafe(no_mangle)]
13296 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_payments(
13297 port_: i64,
13298 that: usize,
13299 req: *mut wire_cst_list_payments_request,
13300 ) {
13301 wire__crate__bindings__BindingLiquidSdk_list_payments_impl(port_, that, req)
13302 }
13303
13304 #[unsafe(no_mangle)]
13305 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_refundables(
13306 port_: i64,
13307 that: usize,
13308 ) {
13309 wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(port_, that)
13310 }
13311
13312 #[unsafe(no_mangle)]
13313 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_auth(
13314 port_: i64,
13315 that: usize,
13316 req_data: *mut wire_cst_ln_url_auth_request_data,
13317 ) {
13318 wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(port_, that, req_data)
13319 }
13320
13321 #[unsafe(no_mangle)]
13322 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_pay(
13323 port_: i64,
13324 that: usize,
13325 req: *mut wire_cst_ln_url_pay_request,
13326 ) {
13327 wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(port_, that, req)
13328 }
13329
13330 #[unsafe(no_mangle)]
13331 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw(
13332 port_: i64,
13333 that: usize,
13334 req: *mut wire_cst_ln_url_withdraw_request,
13335 ) {
13336 wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(port_, that, req)
13337 }
13338
13339 #[unsafe(no_mangle)]
13340 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_parse(
13341 port_: i64,
13342 that: usize,
13343 input: *mut wire_cst_list_prim_u_8_strict,
13344 ) {
13345 wire__crate__bindings__BindingLiquidSdk_parse_impl(port_, that, input)
13346 }
13347
13348 #[unsafe(no_mangle)]
13349 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_pay_onchain(
13350 port_: i64,
13351 that: usize,
13352 req: *mut wire_cst_pay_onchain_request,
13353 ) {
13354 wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(port_, that, req)
13355 }
13356
13357 #[unsafe(no_mangle)]
13358 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin(
13359 port_: i64,
13360 that: usize,
13361 req: *mut wire_cst_prepare_buy_bitcoin_request,
13362 ) {
13363 wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(port_, that, req)
13364 }
13365
13366 #[unsafe(no_mangle)]
13367 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay(
13368 port_: i64,
13369 that: usize,
13370 req: *mut wire_cst_prepare_ln_url_pay_request,
13371 ) {
13372 wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(port_, that, req)
13373 }
13374
13375 #[unsafe(no_mangle)]
13376 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain(
13377 port_: i64,
13378 that: usize,
13379 req: *mut wire_cst_prepare_pay_onchain_request,
13380 ) {
13381 wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(port_, that, req)
13382 }
13383
13384 #[unsafe(no_mangle)]
13385 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment(
13386 port_: i64,
13387 that: usize,
13388 req: *mut wire_cst_prepare_receive_request,
13389 ) {
13390 wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(port_, that, req)
13391 }
13392
13393 #[unsafe(no_mangle)]
13394 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_refund(
13395 port_: i64,
13396 that: usize,
13397 req: *mut wire_cst_prepare_refund_request,
13398 ) {
13399 wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(port_, that, req)
13400 }
13401
13402 #[unsafe(no_mangle)]
13403 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_send_payment(
13404 port_: i64,
13405 that: usize,
13406 req: *mut wire_cst_prepare_send_request,
13407 ) {
13408 wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(port_, that, req)
13409 }
13410
13411 #[unsafe(no_mangle)]
13412 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_receive_payment(
13413 port_: i64,
13414 that: usize,
13415 req: *mut wire_cst_receive_payment_request,
13416 ) {
13417 wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(port_, that, req)
13418 }
13419
13420 #[unsafe(no_mangle)]
13421 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_recommended_fees(
13422 port_: i64,
13423 that: usize,
13424 ) {
13425 wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(port_, that)
13426 }
13427
13428 #[unsafe(no_mangle)]
13429 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_refund(
13430 port_: i64,
13431 that: usize,
13432 req: *mut wire_cst_refund_request,
13433 ) {
13434 wire__crate__bindings__BindingLiquidSdk_refund_impl(port_, that, req)
13435 }
13436
13437 #[unsafe(no_mangle)]
13438 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_register_webhook(
13439 port_: i64,
13440 that: usize,
13441 webhook_url: *mut wire_cst_list_prim_u_8_strict,
13442 ) {
13443 wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(port_, that, webhook_url)
13444 }
13445
13446 #[unsafe(no_mangle)]
13447 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps(
13448 port_: i64,
13449 that: usize,
13450 ) {
13451 wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(port_, that)
13452 }
13453
13454 #[unsafe(no_mangle)]
13455 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_restore(
13456 that: usize,
13457 req: *mut wire_cst_restore_request,
13458 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13459 wire__crate__bindings__BindingLiquidSdk_restore_impl(that, req)
13460 }
13461
13462 #[unsafe(no_mangle)]
13463 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_send_payment(
13464 port_: i64,
13465 that: usize,
13466 req: *mut wire_cst_send_payment_request,
13467 ) {
13468 wire__crate__bindings__BindingLiquidSdk_send_payment_impl(port_, that, req)
13469 }
13470
13471 #[unsafe(no_mangle)]
13472 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sign_message(
13473 that: usize,
13474 req: *mut wire_cst_sign_message_request,
13475 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13476 wire__crate__bindings__BindingLiquidSdk_sign_message_impl(that, req)
13477 }
13478
13479 #[unsafe(no_mangle)]
13480 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sync(
13481 port_: i64,
13482 that: usize,
13483 ) {
13484 wire__crate__bindings__BindingLiquidSdk_sync_impl(port_, that)
13485 }
13486
13487 #[unsafe(no_mangle)]
13488 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_unregister_webhook(
13489 port_: i64,
13490 that: usize,
13491 ) {
13492 wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(port_, that)
13493 }
13494
13495 #[unsafe(no_mangle)]
13496 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__binding_event_listener_on_event(
13497 port_: i64,
13498 that: *mut wire_cst_binding_event_listener,
13499 e: *mut wire_cst_sdk_event,
13500 ) {
13501 wire__crate__bindings__binding_event_listener_on_event_impl(port_, that, e)
13502 }
13503
13504 #[unsafe(no_mangle)]
13505 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__breez_log_stream(
13506 port_: i64,
13507 s: *mut wire_cst_list_prim_u_8_strict,
13508 ) {
13509 wire__crate__bindings__breez_log_stream_impl(port_, s)
13510 }
13511
13512 #[unsafe(no_mangle)]
13513 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__connect(
13514 port_: i64,
13515 req: *mut wire_cst_connect_request,
13516 ) {
13517 wire__crate__bindings__connect_impl(port_, req)
13518 }
13519
13520 #[unsafe(no_mangle)]
13521 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__default_config(
13522 network: i32,
13523 breez_api_key: *mut wire_cst_list_prim_u_8_strict,
13524 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13525 wire__crate__bindings__default_config_impl(network, breez_api_key)
13526 }
13527
13528 #[unsafe(no_mangle)]
13529 pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__parse_invoice(
13530 input: *mut wire_cst_list_prim_u_8_strict,
13531 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13532 wire__crate__bindings__parse_invoice_impl(input)
13533 }
13534
13535 #[unsafe(no_mangle)]
13536 pub extern "C" fn frbgen_breez_liquid_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13537 ptr: *const std::ffi::c_void,
13538 ) {
13539 unsafe {
13540 StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::increment_strong_count(ptr as _);
13541 }
13542 }
13543
13544 #[unsafe(no_mangle)]
13545 pub extern "C" fn frbgen_breez_liquid_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13546 ptr: *const std::ffi::c_void,
13547 ) {
13548 unsafe {
13549 StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::decrement_strong_count(ptr as _);
13550 }
13551 }
13552
13553 #[unsafe(no_mangle)]
13554 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_accept_payment_proposed_fees_request(
13555 ) -> *mut wire_cst_accept_payment_proposed_fees_request {
13556 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13557 wire_cst_accept_payment_proposed_fees_request::new_with_null_ptr(),
13558 )
13559 }
13560
13561 #[unsafe(no_mangle)]
13562 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data(
13563 ) -> *mut wire_cst_aes_success_action_data {
13564 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13565 wire_cst_aes_success_action_data::new_with_null_ptr(),
13566 )
13567 }
13568
13569 #[unsafe(no_mangle)]
13570 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_decrypted(
13571 ) -> *mut wire_cst_aes_success_action_data_decrypted {
13572 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13573 wire_cst_aes_success_action_data_decrypted::new_with_null_ptr(),
13574 )
13575 }
13576
13577 #[unsafe(no_mangle)]
13578 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_result(
13579 ) -> *mut wire_cst_aes_success_action_data_result {
13580 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13581 wire_cst_aes_success_action_data_result::new_with_null_ptr(),
13582 )
13583 }
13584
13585 #[unsafe(no_mangle)]
13586 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_amount() -> *mut wire_cst_amount {
13587 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_amount::new_with_null_ptr())
13588 }
13589
13590 #[unsafe(no_mangle)]
13591 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_asset_info(
13592 ) -> *mut wire_cst_asset_info {
13593 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13594 wire_cst_asset_info::new_with_null_ptr(),
13595 )
13596 }
13597
13598 #[unsafe(no_mangle)]
13599 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_backup_request(
13600 ) -> *mut wire_cst_backup_request {
13601 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13602 wire_cst_backup_request::new_with_null_ptr(),
13603 )
13604 }
13605
13606 #[unsafe(no_mangle)]
13607 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_binding_event_listener(
13608 ) -> *mut wire_cst_binding_event_listener {
13609 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13610 wire_cst_binding_event_listener::new_with_null_ptr(),
13611 )
13612 }
13613
13614 #[unsafe(no_mangle)]
13615 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bitcoin_address_data(
13616 ) -> *mut wire_cst_bitcoin_address_data {
13617 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13618 wire_cst_bitcoin_address_data::new_with_null_ptr(),
13619 )
13620 }
13621
13622 #[unsafe(no_mangle)]
13623 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bool(value: bool) -> *mut bool {
13624 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13625 }
13626
13627 #[unsafe(no_mangle)]
13628 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_buy_bitcoin_request(
13629 ) -> *mut wire_cst_buy_bitcoin_request {
13630 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13631 wire_cst_buy_bitcoin_request::new_with_null_ptr(),
13632 )
13633 }
13634
13635 #[unsafe(no_mangle)]
13636 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_check_message_request(
13637 ) -> *mut wire_cst_check_message_request {
13638 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13639 wire_cst_check_message_request::new_with_null_ptr(),
13640 )
13641 }
13642
13643 #[unsafe(no_mangle)]
13644 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_connect_request(
13645 ) -> *mut wire_cst_connect_request {
13646 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13647 wire_cst_connect_request::new_with_null_ptr(),
13648 )
13649 }
13650
13651 #[unsafe(no_mangle)]
13652 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_create_bolt_12_invoice_request(
13653 ) -> *mut wire_cst_create_bolt_12_invoice_request {
13654 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13655 wire_cst_create_bolt_12_invoice_request::new_with_null_ptr(),
13656 )
13657 }
13658
13659 #[unsafe(no_mangle)]
13660 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_f_64(value: f64) -> *mut f64 {
13661 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13662 }
13663
13664 #[unsafe(no_mangle)]
13665 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_fetch_payment_proposed_fees_request(
13666 ) -> *mut wire_cst_fetch_payment_proposed_fees_request {
13667 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13668 wire_cst_fetch_payment_proposed_fees_request::new_with_null_ptr(),
13669 )
13670 }
13671
13672 #[unsafe(no_mangle)]
13673 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_get_payment_request(
13674 ) -> *mut wire_cst_get_payment_request {
13675 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13676 wire_cst_get_payment_request::new_with_null_ptr(),
13677 )
13678 }
13679
13680 #[unsafe(no_mangle)]
13681 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_i_64(value: i64) -> *mut i64 {
13682 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13683 }
13684
13685 #[unsafe(no_mangle)]
13686 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_liquid_address_data(
13687 ) -> *mut wire_cst_liquid_address_data {
13688 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13689 wire_cst_liquid_address_data::new_with_null_ptr(),
13690 )
13691 }
13692
13693 #[unsafe(no_mangle)]
13694 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payment_details(
13695 ) -> *mut wire_cst_list_payment_details {
13696 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13697 wire_cst_list_payment_details::new_with_null_ptr(),
13698 )
13699 }
13700
13701 #[unsafe(no_mangle)]
13702 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payments_request(
13703 ) -> *mut wire_cst_list_payments_request {
13704 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13705 wire_cst_list_payments_request::new_with_null_ptr(),
13706 )
13707 }
13708
13709 #[unsafe(no_mangle)]
13710 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_invoice(
13711 ) -> *mut wire_cst_ln_invoice {
13712 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13713 wire_cst_ln_invoice::new_with_null_ptr(),
13714 )
13715 }
13716
13717 #[unsafe(no_mangle)]
13718 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_offer() -> *mut wire_cst_ln_offer {
13719 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_ln_offer::new_with_null_ptr())
13720 }
13721
13722 #[unsafe(no_mangle)]
13723 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_auth_request_data(
13724 ) -> *mut wire_cst_ln_url_auth_request_data {
13725 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13726 wire_cst_ln_url_auth_request_data::new_with_null_ptr(),
13727 )
13728 }
13729
13730 #[unsafe(no_mangle)]
13731 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_error_data(
13732 ) -> *mut wire_cst_ln_url_error_data {
13733 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13734 wire_cst_ln_url_error_data::new_with_null_ptr(),
13735 )
13736 }
13737
13738 #[unsafe(no_mangle)]
13739 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_info(
13740 ) -> *mut wire_cst_ln_url_info {
13741 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13742 wire_cst_ln_url_info::new_with_null_ptr(),
13743 )
13744 }
13745
13746 #[unsafe(no_mangle)]
13747 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_error_data(
13748 ) -> *mut wire_cst_ln_url_pay_error_data {
13749 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13750 wire_cst_ln_url_pay_error_data::new_with_null_ptr(),
13751 )
13752 }
13753
13754 #[unsafe(no_mangle)]
13755 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request(
13756 ) -> *mut wire_cst_ln_url_pay_request {
13757 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13758 wire_cst_ln_url_pay_request::new_with_null_ptr(),
13759 )
13760 }
13761
13762 #[unsafe(no_mangle)]
13763 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request_data(
13764 ) -> *mut wire_cst_ln_url_pay_request_data {
13765 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13766 wire_cst_ln_url_pay_request_data::new_with_null_ptr(),
13767 )
13768 }
13769
13770 #[unsafe(no_mangle)]
13771 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_success_data(
13772 ) -> *mut wire_cst_ln_url_pay_success_data {
13773 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13774 wire_cst_ln_url_pay_success_data::new_with_null_ptr(),
13775 )
13776 }
13777
13778 #[unsafe(no_mangle)]
13779 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request(
13780 ) -> *mut wire_cst_ln_url_withdraw_request {
13781 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13782 wire_cst_ln_url_withdraw_request::new_with_null_ptr(),
13783 )
13784 }
13785
13786 #[unsafe(no_mangle)]
13787 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request_data(
13788 ) -> *mut wire_cst_ln_url_withdraw_request_data {
13789 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13790 wire_cst_ln_url_withdraw_request_data::new_with_null_ptr(),
13791 )
13792 }
13793
13794 #[unsafe(no_mangle)]
13795 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_success_data(
13796 ) -> *mut wire_cst_ln_url_withdraw_success_data {
13797 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13798 wire_cst_ln_url_withdraw_success_data::new_with_null_ptr(),
13799 )
13800 }
13801
13802 #[unsafe(no_mangle)]
13803 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_message_success_action_data(
13804 ) -> *mut wire_cst_message_success_action_data {
13805 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13806 wire_cst_message_success_action_data::new_with_null_ptr(),
13807 )
13808 }
13809
13810 #[unsafe(no_mangle)]
13811 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_amount(
13812 ) -> *mut wire_cst_pay_amount {
13813 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13814 wire_cst_pay_amount::new_with_null_ptr(),
13815 )
13816 }
13817
13818 #[unsafe(no_mangle)]
13819 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_onchain_request(
13820 ) -> *mut wire_cst_pay_onchain_request {
13821 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13822 wire_cst_pay_onchain_request::new_with_null_ptr(),
13823 )
13824 }
13825
13826 #[unsafe(no_mangle)]
13827 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_payment() -> *mut wire_cst_payment {
13828 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_payment::new_with_null_ptr())
13829 }
13830
13831 #[unsafe(no_mangle)]
13832 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_buy_bitcoin_request(
13833 ) -> *mut wire_cst_prepare_buy_bitcoin_request {
13834 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13835 wire_cst_prepare_buy_bitcoin_request::new_with_null_ptr(),
13836 )
13837 }
13838
13839 #[unsafe(no_mangle)]
13840 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_ln_url_pay_request(
13841 ) -> *mut wire_cst_prepare_ln_url_pay_request {
13842 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13843 wire_cst_prepare_ln_url_pay_request::new_with_null_ptr(),
13844 )
13845 }
13846
13847 #[unsafe(no_mangle)]
13848 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_pay_onchain_request(
13849 ) -> *mut wire_cst_prepare_pay_onchain_request {
13850 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13851 wire_cst_prepare_pay_onchain_request::new_with_null_ptr(),
13852 )
13853 }
13854
13855 #[unsafe(no_mangle)]
13856 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_receive_request(
13857 ) -> *mut wire_cst_prepare_receive_request {
13858 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13859 wire_cst_prepare_receive_request::new_with_null_ptr(),
13860 )
13861 }
13862
13863 #[unsafe(no_mangle)]
13864 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_refund_request(
13865 ) -> *mut wire_cst_prepare_refund_request {
13866 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13867 wire_cst_prepare_refund_request::new_with_null_ptr(),
13868 )
13869 }
13870
13871 #[unsafe(no_mangle)]
13872 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_send_request(
13873 ) -> *mut wire_cst_prepare_send_request {
13874 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13875 wire_cst_prepare_send_request::new_with_null_ptr(),
13876 )
13877 }
13878
13879 #[unsafe(no_mangle)]
13880 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_amount(
13881 ) -> *mut wire_cst_receive_amount {
13882 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13883 wire_cst_receive_amount::new_with_null_ptr(),
13884 )
13885 }
13886
13887 #[unsafe(no_mangle)]
13888 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_payment_request(
13889 ) -> *mut wire_cst_receive_payment_request {
13890 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13891 wire_cst_receive_payment_request::new_with_null_ptr(),
13892 )
13893 }
13894
13895 #[unsafe(no_mangle)]
13896 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_refund_request(
13897 ) -> *mut wire_cst_refund_request {
13898 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13899 wire_cst_refund_request::new_with_null_ptr(),
13900 )
13901 }
13902
13903 #[unsafe(no_mangle)]
13904 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_restore_request(
13905 ) -> *mut wire_cst_restore_request {
13906 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13907 wire_cst_restore_request::new_with_null_ptr(),
13908 )
13909 }
13910
13911 #[unsafe(no_mangle)]
13912 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sdk_event() -> *mut wire_cst_sdk_event
13913 {
13914 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_sdk_event::new_with_null_ptr())
13915 }
13916
13917 #[unsafe(no_mangle)]
13918 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_send_payment_request(
13919 ) -> *mut wire_cst_send_payment_request {
13920 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13921 wire_cst_send_payment_request::new_with_null_ptr(),
13922 )
13923 }
13924
13925 #[unsafe(no_mangle)]
13926 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sign_message_request(
13927 ) -> *mut wire_cst_sign_message_request {
13928 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13929 wire_cst_sign_message_request::new_with_null_ptr(),
13930 )
13931 }
13932
13933 #[unsafe(no_mangle)]
13934 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action(
13935 ) -> *mut wire_cst_success_action {
13936 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13937 wire_cst_success_action::new_with_null_ptr(),
13938 )
13939 }
13940
13941 #[unsafe(no_mangle)]
13942 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action_processed(
13943 ) -> *mut wire_cst_success_action_processed {
13944 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13945 wire_cst_success_action_processed::new_with_null_ptr(),
13946 )
13947 }
13948
13949 #[unsafe(no_mangle)]
13950 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_symbol() -> *mut wire_cst_symbol {
13951 flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_symbol::new_with_null_ptr())
13952 }
13953
13954 #[unsafe(no_mangle)]
13955 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_32(value: u32) -> *mut u32 {
13956 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13957 }
13958
13959 #[unsafe(no_mangle)]
13960 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_64(value: u64) -> *mut u64 {
13961 flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13962 }
13963
13964 #[unsafe(no_mangle)]
13965 pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_url_success_action_data(
13966 ) -> *mut wire_cst_url_success_action_data {
13967 flutter_rust_bridge::for_generated::new_leak_box_ptr(
13968 wire_cst_url_success_action_data::new_with_null_ptr(),
13969 )
13970 }
13971
13972 #[unsafe(no_mangle)]
13973 pub extern "C" fn frbgen_breez_liquid_cst_new_list_String(
13974 len: i32,
13975 ) -> *mut wire_cst_list_String {
13976 let wrap = wire_cst_list_String {
13977 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13978 <*mut wire_cst_list_prim_u_8_strict>::new_with_null_ptr(),
13979 len,
13980 ),
13981 len,
13982 };
13983 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13984 }
13985
13986 #[unsafe(no_mangle)]
13987 pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_balance(
13988 len: i32,
13989 ) -> *mut wire_cst_list_asset_balance {
13990 let wrap = wire_cst_list_asset_balance {
13991 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13992 <wire_cst_asset_balance>::new_with_null_ptr(),
13993 len,
13994 ),
13995 len,
13996 };
13997 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13998 }
13999
14000 #[unsafe(no_mangle)]
14001 pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_metadata(
14002 len: i32,
14003 ) -> *mut wire_cst_list_asset_metadata {
14004 let wrap = wire_cst_list_asset_metadata {
14005 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14006 <wire_cst_asset_metadata>::new_with_null_ptr(),
14007 len,
14008 ),
14009 len,
14010 };
14011 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14012 }
14013
14014 #[unsafe(no_mangle)]
14015 pub extern "C" fn frbgen_breez_liquid_cst_new_list_external_input_parser(
14016 len: i32,
14017 ) -> *mut wire_cst_list_external_input_parser {
14018 let wrap = wire_cst_list_external_input_parser {
14019 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14020 <wire_cst_external_input_parser>::new_with_null_ptr(),
14021 len,
14022 ),
14023 len,
14024 };
14025 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14026 }
14027
14028 #[unsafe(no_mangle)]
14029 pub extern "C" fn frbgen_breez_liquid_cst_new_list_fiat_currency(
14030 len: i32,
14031 ) -> *mut wire_cst_list_fiat_currency {
14032 let wrap = wire_cst_list_fiat_currency {
14033 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14034 <wire_cst_fiat_currency>::new_with_null_ptr(),
14035 len,
14036 ),
14037 len,
14038 };
14039 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14040 }
14041
14042 #[unsafe(no_mangle)]
14043 pub extern "C" fn frbgen_breez_liquid_cst_new_list_ln_offer_blinded_path(
14044 len: i32,
14045 ) -> *mut wire_cst_list_ln_offer_blinded_path {
14046 let wrap = wire_cst_list_ln_offer_blinded_path {
14047 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14048 <wire_cst_ln_offer_blinded_path>::new_with_null_ptr(),
14049 len,
14050 ),
14051 len,
14052 };
14053 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14054 }
14055
14056 #[unsafe(no_mangle)]
14057 pub extern "C" fn frbgen_breez_liquid_cst_new_list_locale_overrides(
14058 len: i32,
14059 ) -> *mut wire_cst_list_locale_overrides {
14060 let wrap = wire_cst_list_locale_overrides {
14061 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14062 <wire_cst_locale_overrides>::new_with_null_ptr(),
14063 len,
14064 ),
14065 len,
14066 };
14067 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14068 }
14069
14070 #[unsafe(no_mangle)]
14071 pub extern "C" fn frbgen_breez_liquid_cst_new_list_localized_name(
14072 len: i32,
14073 ) -> *mut wire_cst_list_localized_name {
14074 let wrap = wire_cst_list_localized_name {
14075 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14076 <wire_cst_localized_name>::new_with_null_ptr(),
14077 len,
14078 ),
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(
14086 len: i32,
14087 ) -> *mut wire_cst_list_payment {
14088 let wrap = wire_cst_list_payment {
14089 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14090 <wire_cst_payment>::new_with_null_ptr(),
14091 len,
14092 ),
14093 len,
14094 };
14095 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14096 }
14097
14098 #[unsafe(no_mangle)]
14099 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_state(
14100 len: i32,
14101 ) -> *mut wire_cst_list_payment_state {
14102 let wrap = wire_cst_list_payment_state {
14103 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14104 len,
14105 };
14106 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14107 }
14108
14109 #[unsafe(no_mangle)]
14110 pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_type(
14111 len: i32,
14112 ) -> *mut wire_cst_list_payment_type {
14113 let wrap = wire_cst_list_payment_type {
14114 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14115 len,
14116 };
14117 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14118 }
14119
14120 #[unsafe(no_mangle)]
14121 pub extern "C" fn frbgen_breez_liquid_cst_new_list_prim_u_8_strict(
14122 len: i32,
14123 ) -> *mut wire_cst_list_prim_u_8_strict {
14124 let ans = wire_cst_list_prim_u_8_strict {
14125 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14126 len,
14127 };
14128 flutter_rust_bridge::for_generated::new_leak_box_ptr(ans)
14129 }
14130
14131 #[unsafe(no_mangle)]
14132 pub extern "C" fn frbgen_breez_liquid_cst_new_list_rate(len: i32) -> *mut wire_cst_list_rate {
14133 let wrap = wire_cst_list_rate {
14134 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14135 <wire_cst_rate>::new_with_null_ptr(),
14136 len,
14137 ),
14138 len,
14139 };
14140 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14141 }
14142
14143 #[unsafe(no_mangle)]
14144 pub extern "C" fn frbgen_breez_liquid_cst_new_list_refundable_swap(
14145 len: i32,
14146 ) -> *mut wire_cst_list_refundable_swap {
14147 let wrap = wire_cst_list_refundable_swap {
14148 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14149 <wire_cst_refundable_swap>::new_with_null_ptr(),
14150 len,
14151 ),
14152 len,
14153 };
14154 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14155 }
14156
14157 #[unsafe(no_mangle)]
14158 pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint(
14159 len: i32,
14160 ) -> *mut wire_cst_list_route_hint {
14161 let wrap = wire_cst_list_route_hint {
14162 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14163 <wire_cst_route_hint>::new_with_null_ptr(),
14164 len,
14165 ),
14166 len,
14167 };
14168 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14169 }
14170
14171 #[unsafe(no_mangle)]
14172 pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint_hop(
14173 len: i32,
14174 ) -> *mut wire_cst_list_route_hint_hop {
14175 let wrap = wire_cst_list_route_hint_hop {
14176 ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14177 <wire_cst_route_hint_hop>::new_with_null_ptr(),
14178 len,
14179 ),
14180 len,
14181 };
14182 flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14183 }
14184
14185 #[repr(C)]
14186 #[derive(Clone, Copy)]
14187 pub struct wire_cst_accept_payment_proposed_fees_request {
14188 response: wire_cst_fetch_payment_proposed_fees_response,
14189 }
14190 #[repr(C)]
14191 #[derive(Clone, Copy)]
14192 pub struct wire_cst_aes_success_action_data {
14193 description: *mut wire_cst_list_prim_u_8_strict,
14194 ciphertext: *mut wire_cst_list_prim_u_8_strict,
14195 iv: *mut wire_cst_list_prim_u_8_strict,
14196 }
14197 #[repr(C)]
14198 #[derive(Clone, Copy)]
14199 pub struct wire_cst_aes_success_action_data_decrypted {
14200 description: *mut wire_cst_list_prim_u_8_strict,
14201 plaintext: *mut wire_cst_list_prim_u_8_strict,
14202 }
14203 #[repr(C)]
14204 #[derive(Clone, Copy)]
14205 pub struct wire_cst_aes_success_action_data_result {
14206 tag: i32,
14207 kind: AesSuccessActionDataResultKind,
14208 }
14209 #[repr(C)]
14210 #[derive(Clone, Copy)]
14211 pub union AesSuccessActionDataResultKind {
14212 Decrypted: wire_cst_AesSuccessActionDataResult_Decrypted,
14213 ErrorStatus: wire_cst_AesSuccessActionDataResult_ErrorStatus,
14214 nil__: (),
14215 }
14216 #[repr(C)]
14217 #[derive(Clone, Copy)]
14218 pub struct wire_cst_AesSuccessActionDataResult_Decrypted {
14219 data: *mut wire_cst_aes_success_action_data_decrypted,
14220 }
14221 #[repr(C)]
14222 #[derive(Clone, Copy)]
14223 pub struct wire_cst_AesSuccessActionDataResult_ErrorStatus {
14224 reason: *mut wire_cst_list_prim_u_8_strict,
14225 }
14226 #[repr(C)]
14227 #[derive(Clone, Copy)]
14228 pub struct wire_cst_amount {
14229 tag: i32,
14230 kind: AmountKind,
14231 }
14232 #[repr(C)]
14233 #[derive(Clone, Copy)]
14234 pub union AmountKind {
14235 Bitcoin: wire_cst_Amount_Bitcoin,
14236 Currency: wire_cst_Amount_Currency,
14237 nil__: (),
14238 }
14239 #[repr(C)]
14240 #[derive(Clone, Copy)]
14241 pub struct wire_cst_Amount_Bitcoin {
14242 amount_msat: u64,
14243 }
14244 #[repr(C)]
14245 #[derive(Clone, Copy)]
14246 pub struct wire_cst_Amount_Currency {
14247 iso4217_code: *mut wire_cst_list_prim_u_8_strict,
14248 fractional_amount: u64,
14249 }
14250 #[repr(C)]
14251 #[derive(Clone, Copy)]
14252 pub struct wire_cst_asset_balance {
14253 asset_id: *mut wire_cst_list_prim_u_8_strict,
14254 balance_sat: u64,
14255 name: *mut wire_cst_list_prim_u_8_strict,
14256 ticker: *mut wire_cst_list_prim_u_8_strict,
14257 balance: *mut f64,
14258 }
14259 #[repr(C)]
14260 #[derive(Clone, Copy)]
14261 pub struct wire_cst_asset_info {
14262 name: *mut wire_cst_list_prim_u_8_strict,
14263 ticker: *mut wire_cst_list_prim_u_8_strict,
14264 amount: f64,
14265 fees: *mut f64,
14266 }
14267 #[repr(C)]
14268 #[derive(Clone, Copy)]
14269 pub struct wire_cst_asset_metadata {
14270 asset_id: *mut wire_cst_list_prim_u_8_strict,
14271 name: *mut wire_cst_list_prim_u_8_strict,
14272 ticker: *mut wire_cst_list_prim_u_8_strict,
14273 precision: u8,
14274 fiat_id: *mut wire_cst_list_prim_u_8_strict,
14275 }
14276 #[repr(C)]
14277 #[derive(Clone, Copy)]
14278 pub struct wire_cst_backup_request {
14279 backup_path: *mut wire_cst_list_prim_u_8_strict,
14280 }
14281 #[repr(C)]
14282 #[derive(Clone, Copy)]
14283 pub struct wire_cst_binding_event_listener {
14284 stream: *mut wire_cst_list_prim_u_8_strict,
14285 }
14286 #[repr(C)]
14287 #[derive(Clone, Copy)]
14288 pub struct wire_cst_bitcoin_address_data {
14289 address: *mut wire_cst_list_prim_u_8_strict,
14290 network: i32,
14291 amount_sat: *mut u64,
14292 label: *mut wire_cst_list_prim_u_8_strict,
14293 message: *mut wire_cst_list_prim_u_8_strict,
14294 }
14295 #[repr(C)]
14296 #[derive(Clone, Copy)]
14297 pub struct wire_cst_blockchain_explorer {
14298 tag: i32,
14299 kind: BlockchainExplorerKind,
14300 }
14301 #[repr(C)]
14302 #[derive(Clone, Copy)]
14303 pub union BlockchainExplorerKind {
14304 Electrum: wire_cst_BlockchainExplorer_Electrum,
14305 Esplora: wire_cst_BlockchainExplorer_Esplora,
14306 nil__: (),
14307 }
14308 #[repr(C)]
14309 #[derive(Clone, Copy)]
14310 pub struct wire_cst_BlockchainExplorer_Electrum {
14311 url: *mut wire_cst_list_prim_u_8_strict,
14312 }
14313 #[repr(C)]
14314 #[derive(Clone, Copy)]
14315 pub struct wire_cst_BlockchainExplorer_Esplora {
14316 url: *mut wire_cst_list_prim_u_8_strict,
14317 use_waterfalls: bool,
14318 }
14319 #[repr(C)]
14320 #[derive(Clone, Copy)]
14321 pub struct wire_cst_blockchain_info {
14322 liquid_tip: u32,
14323 bitcoin_tip: u32,
14324 }
14325 #[repr(C)]
14326 #[derive(Clone, Copy)]
14327 pub struct wire_cst_buy_bitcoin_request {
14328 prepare_response: wire_cst_prepare_buy_bitcoin_response,
14329 redirect_url: *mut wire_cst_list_prim_u_8_strict,
14330 }
14331 #[repr(C)]
14332 #[derive(Clone, Copy)]
14333 pub struct wire_cst_check_message_request {
14334 message: *mut wire_cst_list_prim_u_8_strict,
14335 pubkey: *mut wire_cst_list_prim_u_8_strict,
14336 signature: *mut wire_cst_list_prim_u_8_strict,
14337 }
14338 #[repr(C)]
14339 #[derive(Clone, Copy)]
14340 pub struct wire_cst_check_message_response {
14341 is_valid: bool,
14342 }
14343 #[repr(C)]
14344 #[derive(Clone, Copy)]
14345 pub struct wire_cst_config {
14346 liquid_explorer: wire_cst_blockchain_explorer,
14347 bitcoin_explorer: wire_cst_blockchain_explorer,
14348 working_dir: *mut wire_cst_list_prim_u_8_strict,
14349 network: i32,
14350 payment_timeout_sec: u64,
14351 sync_service_url: *mut wire_cst_list_prim_u_8_strict,
14352 zero_conf_max_amount_sat: *mut u64,
14353 breez_api_key: *mut wire_cst_list_prim_u_8_strict,
14354 external_input_parsers: *mut wire_cst_list_external_input_parser,
14355 use_default_external_input_parsers: bool,
14356 onchain_fee_rate_leeway_sat: *mut u64,
14357 asset_metadata: *mut wire_cst_list_asset_metadata,
14358 sideswap_api_key: *mut wire_cst_list_prim_u_8_strict,
14359 }
14360 #[repr(C)]
14361 #[derive(Clone, Copy)]
14362 pub struct wire_cst_connect_request {
14363 config: wire_cst_config,
14364 mnemonic: *mut wire_cst_list_prim_u_8_strict,
14365 passphrase: *mut wire_cst_list_prim_u_8_strict,
14366 seed: *mut wire_cst_list_prim_u_8_strict,
14367 }
14368 #[repr(C)]
14369 #[derive(Clone, Copy)]
14370 pub struct wire_cst_create_bolt_12_invoice_request {
14371 offer: *mut wire_cst_list_prim_u_8_strict,
14372 invoice_request: *mut wire_cst_list_prim_u_8_strict,
14373 }
14374 #[repr(C)]
14375 #[derive(Clone, Copy)]
14376 pub struct wire_cst_create_bolt_12_invoice_response {
14377 invoice: *mut wire_cst_list_prim_u_8_strict,
14378 }
14379 #[repr(C)]
14380 #[derive(Clone, Copy)]
14381 pub struct wire_cst_currency_info {
14382 name: *mut wire_cst_list_prim_u_8_strict,
14383 fraction_size: u32,
14384 spacing: *mut u32,
14385 symbol: *mut wire_cst_symbol,
14386 uniq_symbol: *mut wire_cst_symbol,
14387 localized_name: *mut wire_cst_list_localized_name,
14388 locale_overrides: *mut wire_cst_list_locale_overrides,
14389 }
14390 #[repr(C)]
14391 #[derive(Clone, Copy)]
14392 pub struct wire_cst_external_input_parser {
14393 provider_id: *mut wire_cst_list_prim_u_8_strict,
14394 input_regex: *mut wire_cst_list_prim_u_8_strict,
14395 parser_url: *mut wire_cst_list_prim_u_8_strict,
14396 }
14397 #[repr(C)]
14398 #[derive(Clone, Copy)]
14399 pub struct wire_cst_fetch_payment_proposed_fees_request {
14400 swap_id: *mut wire_cst_list_prim_u_8_strict,
14401 }
14402 #[repr(C)]
14403 #[derive(Clone, Copy)]
14404 pub struct wire_cst_fetch_payment_proposed_fees_response {
14405 swap_id: *mut wire_cst_list_prim_u_8_strict,
14406 fees_sat: u64,
14407 payer_amount_sat: u64,
14408 receiver_amount_sat: u64,
14409 }
14410 #[repr(C)]
14411 #[derive(Clone, Copy)]
14412 pub struct wire_cst_fiat_currency {
14413 id: *mut wire_cst_list_prim_u_8_strict,
14414 info: wire_cst_currency_info,
14415 }
14416 #[repr(C)]
14417 #[derive(Clone, Copy)]
14418 pub struct wire_cst_get_info_response {
14419 wallet_info: wire_cst_wallet_info,
14420 blockchain_info: wire_cst_blockchain_info,
14421 }
14422 #[repr(C)]
14423 #[derive(Clone, Copy)]
14424 pub struct wire_cst_get_payment_request {
14425 tag: i32,
14426 kind: GetPaymentRequestKind,
14427 }
14428 #[repr(C)]
14429 #[derive(Clone, Copy)]
14430 pub union GetPaymentRequestKind {
14431 PaymentHash: wire_cst_GetPaymentRequest_PaymentHash,
14432 SwapId: wire_cst_GetPaymentRequest_SwapId,
14433 nil__: (),
14434 }
14435 #[repr(C)]
14436 #[derive(Clone, Copy)]
14437 pub struct wire_cst_GetPaymentRequest_PaymentHash {
14438 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14439 }
14440 #[repr(C)]
14441 #[derive(Clone, Copy)]
14442 pub struct wire_cst_GetPaymentRequest_SwapId {
14443 swap_id: *mut wire_cst_list_prim_u_8_strict,
14444 }
14445 #[repr(C)]
14446 #[derive(Clone, Copy)]
14447 pub struct wire_cst_input_type {
14448 tag: i32,
14449 kind: InputTypeKind,
14450 }
14451 #[repr(C)]
14452 #[derive(Clone, Copy)]
14453 pub union InputTypeKind {
14454 BitcoinAddress: wire_cst_InputType_BitcoinAddress,
14455 LiquidAddress: wire_cst_InputType_LiquidAddress,
14456 Bolt11: wire_cst_InputType_Bolt11,
14457 Bolt12Offer: wire_cst_InputType_Bolt12Offer,
14458 NodeId: wire_cst_InputType_NodeId,
14459 Url: wire_cst_InputType_Url,
14460 LnUrlPay: wire_cst_InputType_LnUrlPay,
14461 LnUrlWithdraw: wire_cst_InputType_LnUrlWithdraw,
14462 LnUrlAuth: wire_cst_InputType_LnUrlAuth,
14463 LnUrlError: wire_cst_InputType_LnUrlError,
14464 nil__: (),
14465 }
14466 #[repr(C)]
14467 #[derive(Clone, Copy)]
14468 pub struct wire_cst_InputType_BitcoinAddress {
14469 address: *mut wire_cst_bitcoin_address_data,
14470 }
14471 #[repr(C)]
14472 #[derive(Clone, Copy)]
14473 pub struct wire_cst_InputType_LiquidAddress {
14474 address: *mut wire_cst_liquid_address_data,
14475 }
14476 #[repr(C)]
14477 #[derive(Clone, Copy)]
14478 pub struct wire_cst_InputType_Bolt11 {
14479 invoice: *mut wire_cst_ln_invoice,
14480 }
14481 #[repr(C)]
14482 #[derive(Clone, Copy)]
14483 pub struct wire_cst_InputType_Bolt12Offer {
14484 offer: *mut wire_cst_ln_offer,
14485 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14486 }
14487 #[repr(C)]
14488 #[derive(Clone, Copy)]
14489 pub struct wire_cst_InputType_NodeId {
14490 node_id: *mut wire_cst_list_prim_u_8_strict,
14491 }
14492 #[repr(C)]
14493 #[derive(Clone, Copy)]
14494 pub struct wire_cst_InputType_Url {
14495 url: *mut wire_cst_list_prim_u_8_strict,
14496 }
14497 #[repr(C)]
14498 #[derive(Clone, Copy)]
14499 pub struct wire_cst_InputType_LnUrlPay {
14500 data: *mut wire_cst_ln_url_pay_request_data,
14501 bip353_address: *mut wire_cst_list_prim_u_8_strict,
14502 }
14503 #[repr(C)]
14504 #[derive(Clone, Copy)]
14505 pub struct wire_cst_InputType_LnUrlWithdraw {
14506 data: *mut wire_cst_ln_url_withdraw_request_data,
14507 }
14508 #[repr(C)]
14509 #[derive(Clone, Copy)]
14510 pub struct wire_cst_InputType_LnUrlAuth {
14511 data: *mut wire_cst_ln_url_auth_request_data,
14512 }
14513 #[repr(C)]
14514 #[derive(Clone, Copy)]
14515 pub struct wire_cst_InputType_LnUrlError {
14516 data: *mut wire_cst_ln_url_error_data,
14517 }
14518 #[repr(C)]
14519 #[derive(Clone, Copy)]
14520 pub struct wire_cst_lightning_payment_limits_response {
14521 send: wire_cst_limits,
14522 receive: wire_cst_limits,
14523 }
14524 #[repr(C)]
14525 #[derive(Clone, Copy)]
14526 pub struct wire_cst_limits {
14527 min_sat: u64,
14528 max_sat: u64,
14529 max_zero_conf_sat: u64,
14530 }
14531 #[repr(C)]
14532 #[derive(Clone, Copy)]
14533 pub struct wire_cst_liquid_address_data {
14534 address: *mut wire_cst_list_prim_u_8_strict,
14535 network: i32,
14536 asset_id: *mut wire_cst_list_prim_u_8_strict,
14537 amount: *mut f64,
14538 amount_sat: *mut u64,
14539 label: *mut wire_cst_list_prim_u_8_strict,
14540 message: *mut wire_cst_list_prim_u_8_strict,
14541 }
14542 #[repr(C)]
14543 #[derive(Clone, Copy)]
14544 pub struct wire_cst_list_String {
14545 ptr: *mut *mut wire_cst_list_prim_u_8_strict,
14546 len: i32,
14547 }
14548 #[repr(C)]
14549 #[derive(Clone, Copy)]
14550 pub struct wire_cst_list_asset_balance {
14551 ptr: *mut wire_cst_asset_balance,
14552 len: i32,
14553 }
14554 #[repr(C)]
14555 #[derive(Clone, Copy)]
14556 pub struct wire_cst_list_asset_metadata {
14557 ptr: *mut wire_cst_asset_metadata,
14558 len: i32,
14559 }
14560 #[repr(C)]
14561 #[derive(Clone, Copy)]
14562 pub struct wire_cst_list_external_input_parser {
14563 ptr: *mut wire_cst_external_input_parser,
14564 len: i32,
14565 }
14566 #[repr(C)]
14567 #[derive(Clone, Copy)]
14568 pub struct wire_cst_list_fiat_currency {
14569 ptr: *mut wire_cst_fiat_currency,
14570 len: i32,
14571 }
14572 #[repr(C)]
14573 #[derive(Clone, Copy)]
14574 pub struct wire_cst_list_ln_offer_blinded_path {
14575 ptr: *mut wire_cst_ln_offer_blinded_path,
14576 len: i32,
14577 }
14578 #[repr(C)]
14579 #[derive(Clone, Copy)]
14580 pub struct wire_cst_list_locale_overrides {
14581 ptr: *mut wire_cst_locale_overrides,
14582 len: i32,
14583 }
14584 #[repr(C)]
14585 #[derive(Clone, Copy)]
14586 pub struct wire_cst_list_localized_name {
14587 ptr: *mut wire_cst_localized_name,
14588 len: i32,
14589 }
14590 #[repr(C)]
14591 #[derive(Clone, Copy)]
14592 pub struct wire_cst_list_payment {
14593 ptr: *mut wire_cst_payment,
14594 len: i32,
14595 }
14596 #[repr(C)]
14597 #[derive(Clone, Copy)]
14598 pub struct wire_cst_list_payment_details {
14599 tag: i32,
14600 kind: ListPaymentDetailsKind,
14601 }
14602 #[repr(C)]
14603 #[derive(Clone, Copy)]
14604 pub union ListPaymentDetailsKind {
14605 Liquid: wire_cst_ListPaymentDetails_Liquid,
14606 Bitcoin: wire_cst_ListPaymentDetails_Bitcoin,
14607 nil__: (),
14608 }
14609 #[repr(C)]
14610 #[derive(Clone, Copy)]
14611 pub struct wire_cst_ListPaymentDetails_Liquid {
14612 asset_id: *mut wire_cst_list_prim_u_8_strict,
14613 destination: *mut wire_cst_list_prim_u_8_strict,
14614 }
14615 #[repr(C)]
14616 #[derive(Clone, Copy)]
14617 pub struct wire_cst_ListPaymentDetails_Bitcoin {
14618 address: *mut wire_cst_list_prim_u_8_strict,
14619 }
14620 #[repr(C)]
14621 #[derive(Clone, Copy)]
14622 pub struct wire_cst_list_payment_state {
14623 ptr: *mut i32,
14624 len: i32,
14625 }
14626 #[repr(C)]
14627 #[derive(Clone, Copy)]
14628 pub struct wire_cst_list_payment_type {
14629 ptr: *mut i32,
14630 len: i32,
14631 }
14632 #[repr(C)]
14633 #[derive(Clone, Copy)]
14634 pub struct wire_cst_list_payments_request {
14635 filters: *mut wire_cst_list_payment_type,
14636 states: *mut wire_cst_list_payment_state,
14637 from_timestamp: *mut i64,
14638 to_timestamp: *mut i64,
14639 offset: *mut u32,
14640 limit: *mut u32,
14641 details: *mut wire_cst_list_payment_details,
14642 sort_ascending: *mut bool,
14643 }
14644 #[repr(C)]
14645 #[derive(Clone, Copy)]
14646 pub struct wire_cst_list_prim_u_8_strict {
14647 ptr: *mut u8,
14648 len: i32,
14649 }
14650 #[repr(C)]
14651 #[derive(Clone, Copy)]
14652 pub struct wire_cst_list_rate {
14653 ptr: *mut wire_cst_rate,
14654 len: i32,
14655 }
14656 #[repr(C)]
14657 #[derive(Clone, Copy)]
14658 pub struct wire_cst_list_refundable_swap {
14659 ptr: *mut wire_cst_refundable_swap,
14660 len: i32,
14661 }
14662 #[repr(C)]
14663 #[derive(Clone, Copy)]
14664 pub struct wire_cst_list_route_hint {
14665 ptr: *mut wire_cst_route_hint,
14666 len: i32,
14667 }
14668 #[repr(C)]
14669 #[derive(Clone, Copy)]
14670 pub struct wire_cst_list_route_hint_hop {
14671 ptr: *mut wire_cst_route_hint_hop,
14672 len: i32,
14673 }
14674 #[repr(C)]
14675 #[derive(Clone, Copy)]
14676 pub struct wire_cst_ln_invoice {
14677 bolt11: *mut wire_cst_list_prim_u_8_strict,
14678 network: i32,
14679 payee_pubkey: *mut wire_cst_list_prim_u_8_strict,
14680 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14681 description: *mut wire_cst_list_prim_u_8_strict,
14682 description_hash: *mut wire_cst_list_prim_u_8_strict,
14683 amount_msat: *mut u64,
14684 timestamp: u64,
14685 expiry: u64,
14686 routing_hints: *mut wire_cst_list_route_hint,
14687 payment_secret: *mut wire_cst_list_prim_u_8_strict,
14688 min_final_cltv_expiry_delta: u64,
14689 }
14690 #[repr(C)]
14691 #[derive(Clone, Copy)]
14692 pub struct wire_cst_ln_offer {
14693 offer: *mut wire_cst_list_prim_u_8_strict,
14694 chains: *mut wire_cst_list_String,
14695 min_amount: *mut wire_cst_amount,
14696 description: *mut wire_cst_list_prim_u_8_strict,
14697 absolute_expiry: *mut u64,
14698 issuer: *mut wire_cst_list_prim_u_8_strict,
14699 signing_pubkey: *mut wire_cst_list_prim_u_8_strict,
14700 paths: *mut wire_cst_list_ln_offer_blinded_path,
14701 }
14702 #[repr(C)]
14703 #[derive(Clone, Copy)]
14704 pub struct wire_cst_ln_offer_blinded_path {
14705 blinded_hops: *mut wire_cst_list_String,
14706 }
14707 #[repr(C)]
14708 #[derive(Clone, Copy)]
14709 pub struct wire_cst_ln_url_auth_error {
14710 tag: i32,
14711 kind: LnUrlAuthErrorKind,
14712 }
14713 #[repr(C)]
14714 #[derive(Clone, Copy)]
14715 pub union LnUrlAuthErrorKind {
14716 Generic: wire_cst_LnUrlAuthError_Generic,
14717 InvalidUri: wire_cst_LnUrlAuthError_InvalidUri,
14718 ServiceConnectivity: wire_cst_LnUrlAuthError_ServiceConnectivity,
14719 nil__: (),
14720 }
14721 #[repr(C)]
14722 #[derive(Clone, Copy)]
14723 pub struct wire_cst_LnUrlAuthError_Generic {
14724 err: *mut wire_cst_list_prim_u_8_strict,
14725 }
14726 #[repr(C)]
14727 #[derive(Clone, Copy)]
14728 pub struct wire_cst_LnUrlAuthError_InvalidUri {
14729 err: *mut wire_cst_list_prim_u_8_strict,
14730 }
14731 #[repr(C)]
14732 #[derive(Clone, Copy)]
14733 pub struct wire_cst_LnUrlAuthError_ServiceConnectivity {
14734 err: *mut wire_cst_list_prim_u_8_strict,
14735 }
14736 #[repr(C)]
14737 #[derive(Clone, Copy)]
14738 pub struct wire_cst_ln_url_auth_request_data {
14739 k1: *mut wire_cst_list_prim_u_8_strict,
14740 action: *mut wire_cst_list_prim_u_8_strict,
14741 domain: *mut wire_cst_list_prim_u_8_strict,
14742 url: *mut wire_cst_list_prim_u_8_strict,
14743 }
14744 #[repr(C)]
14745 #[derive(Clone, Copy)]
14746 pub struct wire_cst_ln_url_callback_status {
14747 tag: i32,
14748 kind: LnUrlCallbackStatusKind,
14749 }
14750 #[repr(C)]
14751 #[derive(Clone, Copy)]
14752 pub union LnUrlCallbackStatusKind {
14753 ErrorStatus: wire_cst_LnUrlCallbackStatus_ErrorStatus,
14754 nil__: (),
14755 }
14756 #[repr(C)]
14757 #[derive(Clone, Copy)]
14758 pub struct wire_cst_LnUrlCallbackStatus_ErrorStatus {
14759 data: *mut wire_cst_ln_url_error_data,
14760 }
14761 #[repr(C)]
14762 #[derive(Clone, Copy)]
14763 pub struct wire_cst_ln_url_error_data {
14764 reason: *mut wire_cst_list_prim_u_8_strict,
14765 }
14766 #[repr(C)]
14767 #[derive(Clone, Copy)]
14768 pub struct wire_cst_ln_url_info {
14769 ln_address: *mut wire_cst_list_prim_u_8_strict,
14770 lnurl_pay_comment: *mut wire_cst_list_prim_u_8_strict,
14771 lnurl_pay_domain: *mut wire_cst_list_prim_u_8_strict,
14772 lnurl_pay_metadata: *mut wire_cst_list_prim_u_8_strict,
14773 lnurl_pay_success_action: *mut wire_cst_success_action_processed,
14774 lnurl_pay_unprocessed_success_action: *mut wire_cst_success_action,
14775 lnurl_withdraw_endpoint: *mut wire_cst_list_prim_u_8_strict,
14776 }
14777 #[repr(C)]
14778 #[derive(Clone, Copy)]
14779 pub struct wire_cst_ln_url_pay_error {
14780 tag: i32,
14781 kind: LnUrlPayErrorKind,
14782 }
14783 #[repr(C)]
14784 #[derive(Clone, Copy)]
14785 pub union LnUrlPayErrorKind {
14786 Generic: wire_cst_LnUrlPayError_Generic,
14787 InsufficientBalance: wire_cst_LnUrlPayError_InsufficientBalance,
14788 InvalidAmount: wire_cst_LnUrlPayError_InvalidAmount,
14789 InvalidInvoice: wire_cst_LnUrlPayError_InvalidInvoice,
14790 InvalidNetwork: wire_cst_LnUrlPayError_InvalidNetwork,
14791 InvalidUri: wire_cst_LnUrlPayError_InvalidUri,
14792 InvoiceExpired: wire_cst_LnUrlPayError_InvoiceExpired,
14793 PaymentFailed: wire_cst_LnUrlPayError_PaymentFailed,
14794 PaymentTimeout: wire_cst_LnUrlPayError_PaymentTimeout,
14795 RouteNotFound: wire_cst_LnUrlPayError_RouteNotFound,
14796 RouteTooExpensive: wire_cst_LnUrlPayError_RouteTooExpensive,
14797 ServiceConnectivity: wire_cst_LnUrlPayError_ServiceConnectivity,
14798 nil__: (),
14799 }
14800 #[repr(C)]
14801 #[derive(Clone, Copy)]
14802 pub struct wire_cst_LnUrlPayError_Generic {
14803 err: *mut wire_cst_list_prim_u_8_strict,
14804 }
14805 #[repr(C)]
14806 #[derive(Clone, Copy)]
14807 pub struct wire_cst_LnUrlPayError_InsufficientBalance {
14808 err: *mut wire_cst_list_prim_u_8_strict,
14809 }
14810 #[repr(C)]
14811 #[derive(Clone, Copy)]
14812 pub struct wire_cst_LnUrlPayError_InvalidAmount {
14813 err: *mut wire_cst_list_prim_u_8_strict,
14814 }
14815 #[repr(C)]
14816 #[derive(Clone, Copy)]
14817 pub struct wire_cst_LnUrlPayError_InvalidInvoice {
14818 err: *mut wire_cst_list_prim_u_8_strict,
14819 }
14820 #[repr(C)]
14821 #[derive(Clone, Copy)]
14822 pub struct wire_cst_LnUrlPayError_InvalidNetwork {
14823 err: *mut wire_cst_list_prim_u_8_strict,
14824 }
14825 #[repr(C)]
14826 #[derive(Clone, Copy)]
14827 pub struct wire_cst_LnUrlPayError_InvalidUri {
14828 err: *mut wire_cst_list_prim_u_8_strict,
14829 }
14830 #[repr(C)]
14831 #[derive(Clone, Copy)]
14832 pub struct wire_cst_LnUrlPayError_InvoiceExpired {
14833 err: *mut wire_cst_list_prim_u_8_strict,
14834 }
14835 #[repr(C)]
14836 #[derive(Clone, Copy)]
14837 pub struct wire_cst_LnUrlPayError_PaymentFailed {
14838 err: *mut wire_cst_list_prim_u_8_strict,
14839 }
14840 #[repr(C)]
14841 #[derive(Clone, Copy)]
14842 pub struct wire_cst_LnUrlPayError_PaymentTimeout {
14843 err: *mut wire_cst_list_prim_u_8_strict,
14844 }
14845 #[repr(C)]
14846 #[derive(Clone, Copy)]
14847 pub struct wire_cst_LnUrlPayError_RouteNotFound {
14848 err: *mut wire_cst_list_prim_u_8_strict,
14849 }
14850 #[repr(C)]
14851 #[derive(Clone, Copy)]
14852 pub struct wire_cst_LnUrlPayError_RouteTooExpensive {
14853 err: *mut wire_cst_list_prim_u_8_strict,
14854 }
14855 #[repr(C)]
14856 #[derive(Clone, Copy)]
14857 pub struct wire_cst_LnUrlPayError_ServiceConnectivity {
14858 err: *mut wire_cst_list_prim_u_8_strict,
14859 }
14860 #[repr(C)]
14861 #[derive(Clone, Copy)]
14862 pub struct wire_cst_ln_url_pay_error_data {
14863 payment_hash: *mut wire_cst_list_prim_u_8_strict,
14864 reason: *mut wire_cst_list_prim_u_8_strict,
14865 }
14866 #[repr(C)]
14867 #[derive(Clone, Copy)]
14868 pub struct wire_cst_ln_url_pay_request {
14869 prepare_response: wire_cst_prepare_ln_url_pay_response,
14870 }
14871 #[repr(C)]
14872 #[derive(Clone, Copy)]
14873 pub struct wire_cst_ln_url_pay_request_data {
14874 callback: *mut wire_cst_list_prim_u_8_strict,
14875 min_sendable: u64,
14876 max_sendable: u64,
14877 metadata_str: *mut wire_cst_list_prim_u_8_strict,
14878 comment_allowed: u16,
14879 domain: *mut wire_cst_list_prim_u_8_strict,
14880 allows_nostr: bool,
14881 nostr_pubkey: *mut wire_cst_list_prim_u_8_strict,
14882 ln_address: *mut wire_cst_list_prim_u_8_strict,
14883 }
14884 #[repr(C)]
14885 #[derive(Clone, Copy)]
14886 pub struct wire_cst_ln_url_pay_result {
14887 tag: i32,
14888 kind: LnUrlPayResultKind,
14889 }
14890 #[repr(C)]
14891 #[derive(Clone, Copy)]
14892 pub union LnUrlPayResultKind {
14893 EndpointSuccess: wire_cst_LnUrlPayResult_EndpointSuccess,
14894 EndpointError: wire_cst_LnUrlPayResult_EndpointError,
14895 PayError: wire_cst_LnUrlPayResult_PayError,
14896 nil__: (),
14897 }
14898 #[repr(C)]
14899 #[derive(Clone, Copy)]
14900 pub struct wire_cst_LnUrlPayResult_EndpointSuccess {
14901 data: *mut wire_cst_ln_url_pay_success_data,
14902 }
14903 #[repr(C)]
14904 #[derive(Clone, Copy)]
14905 pub struct wire_cst_LnUrlPayResult_EndpointError {
14906 data: *mut wire_cst_ln_url_error_data,
14907 }
14908 #[repr(C)]
14909 #[derive(Clone, Copy)]
14910 pub struct wire_cst_LnUrlPayResult_PayError {
14911 data: *mut wire_cst_ln_url_pay_error_data,
14912 }
14913 #[repr(C)]
14914 #[derive(Clone, Copy)]
14915 pub struct wire_cst_ln_url_pay_success_data {
14916 payment: wire_cst_payment,
14917 success_action: *mut wire_cst_success_action_processed,
14918 }
14919 #[repr(C)]
14920 #[derive(Clone, Copy)]
14921 pub struct wire_cst_ln_url_withdraw_error {
14922 tag: i32,
14923 kind: LnUrlWithdrawErrorKind,
14924 }
14925 #[repr(C)]
14926 #[derive(Clone, Copy)]
14927 pub union LnUrlWithdrawErrorKind {
14928 Generic: wire_cst_LnUrlWithdrawError_Generic,
14929 InvalidAmount: wire_cst_LnUrlWithdrawError_InvalidAmount,
14930 InvalidInvoice: wire_cst_LnUrlWithdrawError_InvalidInvoice,
14931 InvalidUri: wire_cst_LnUrlWithdrawError_InvalidUri,
14932 InvoiceNoRoutingHints: wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints,
14933 ServiceConnectivity: wire_cst_LnUrlWithdrawError_ServiceConnectivity,
14934 nil__: (),
14935 }
14936 #[repr(C)]
14937 #[derive(Clone, Copy)]
14938 pub struct wire_cst_LnUrlWithdrawError_Generic {
14939 err: *mut wire_cst_list_prim_u_8_strict,
14940 }
14941 #[repr(C)]
14942 #[derive(Clone, Copy)]
14943 pub struct wire_cst_LnUrlWithdrawError_InvalidAmount {
14944 err: *mut wire_cst_list_prim_u_8_strict,
14945 }
14946 #[repr(C)]
14947 #[derive(Clone, Copy)]
14948 pub struct wire_cst_LnUrlWithdrawError_InvalidInvoice {
14949 err: *mut wire_cst_list_prim_u_8_strict,
14950 }
14951 #[repr(C)]
14952 #[derive(Clone, Copy)]
14953 pub struct wire_cst_LnUrlWithdrawError_InvalidUri {
14954 err: *mut wire_cst_list_prim_u_8_strict,
14955 }
14956 #[repr(C)]
14957 #[derive(Clone, Copy)]
14958 pub struct wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints {
14959 err: *mut wire_cst_list_prim_u_8_strict,
14960 }
14961 #[repr(C)]
14962 #[derive(Clone, Copy)]
14963 pub struct wire_cst_LnUrlWithdrawError_ServiceConnectivity {
14964 err: *mut wire_cst_list_prim_u_8_strict,
14965 }
14966 #[repr(C)]
14967 #[derive(Clone, Copy)]
14968 pub struct wire_cst_ln_url_withdraw_request {
14969 data: wire_cst_ln_url_withdraw_request_data,
14970 amount_msat: u64,
14971 description: *mut wire_cst_list_prim_u_8_strict,
14972 }
14973 #[repr(C)]
14974 #[derive(Clone, Copy)]
14975 pub struct wire_cst_ln_url_withdraw_request_data {
14976 callback: *mut wire_cst_list_prim_u_8_strict,
14977 k1: *mut wire_cst_list_prim_u_8_strict,
14978 default_description: *mut wire_cst_list_prim_u_8_strict,
14979 min_withdrawable: u64,
14980 max_withdrawable: u64,
14981 }
14982 #[repr(C)]
14983 #[derive(Clone, Copy)]
14984 pub struct wire_cst_ln_url_withdraw_result {
14985 tag: i32,
14986 kind: LnUrlWithdrawResultKind,
14987 }
14988 #[repr(C)]
14989 #[derive(Clone, Copy)]
14990 pub union LnUrlWithdrawResultKind {
14991 Ok: wire_cst_LnUrlWithdrawResult_Ok,
14992 Timeout: wire_cst_LnUrlWithdrawResult_Timeout,
14993 ErrorStatus: wire_cst_LnUrlWithdrawResult_ErrorStatus,
14994 nil__: (),
14995 }
14996 #[repr(C)]
14997 #[derive(Clone, Copy)]
14998 pub struct wire_cst_LnUrlWithdrawResult_Ok {
14999 data: *mut wire_cst_ln_url_withdraw_success_data,
15000 }
15001 #[repr(C)]
15002 #[derive(Clone, Copy)]
15003 pub struct wire_cst_LnUrlWithdrawResult_Timeout {
15004 data: *mut wire_cst_ln_url_withdraw_success_data,
15005 }
15006 #[repr(C)]
15007 #[derive(Clone, Copy)]
15008 pub struct wire_cst_LnUrlWithdrawResult_ErrorStatus {
15009 data: *mut wire_cst_ln_url_error_data,
15010 }
15011 #[repr(C)]
15012 #[derive(Clone, Copy)]
15013 pub struct wire_cst_ln_url_withdraw_success_data {
15014 invoice: wire_cst_ln_invoice,
15015 }
15016 #[repr(C)]
15017 #[derive(Clone, Copy)]
15018 pub struct wire_cst_locale_overrides {
15019 locale: *mut wire_cst_list_prim_u_8_strict,
15020 spacing: *mut u32,
15021 symbol: wire_cst_symbol,
15022 }
15023 #[repr(C)]
15024 #[derive(Clone, Copy)]
15025 pub struct wire_cst_localized_name {
15026 locale: *mut wire_cst_list_prim_u_8_strict,
15027 name: *mut wire_cst_list_prim_u_8_strict,
15028 }
15029 #[repr(C)]
15030 #[derive(Clone, Copy)]
15031 pub struct wire_cst_log_entry {
15032 line: *mut wire_cst_list_prim_u_8_strict,
15033 level: *mut wire_cst_list_prim_u_8_strict,
15034 }
15035 #[repr(C)]
15036 #[derive(Clone, Copy)]
15037 pub struct wire_cst_message_success_action_data {
15038 message: *mut wire_cst_list_prim_u_8_strict,
15039 }
15040 #[repr(C)]
15041 #[derive(Clone, Copy)]
15042 pub struct wire_cst_onchain_payment_limits_response {
15043 send: wire_cst_limits,
15044 receive: wire_cst_limits,
15045 }
15046 #[repr(C)]
15047 #[derive(Clone, Copy)]
15048 pub struct wire_cst_pay_amount {
15049 tag: i32,
15050 kind: PayAmountKind,
15051 }
15052 #[repr(C)]
15053 #[derive(Clone, Copy)]
15054 pub union PayAmountKind {
15055 Bitcoin: wire_cst_PayAmount_Bitcoin,
15056 Asset: wire_cst_PayAmount_Asset,
15057 nil__: (),
15058 }
15059 #[repr(C)]
15060 #[derive(Clone, Copy)]
15061 pub struct wire_cst_PayAmount_Bitcoin {
15062 receiver_amount_sat: u64,
15063 }
15064 #[repr(C)]
15065 #[derive(Clone, Copy)]
15066 pub struct wire_cst_PayAmount_Asset {
15067 asset_id: *mut wire_cst_list_prim_u_8_strict,
15068 receiver_amount: f64,
15069 estimate_asset_fees: *mut bool,
15070 }
15071 #[repr(C)]
15072 #[derive(Clone, Copy)]
15073 pub struct wire_cst_pay_onchain_request {
15074 address: *mut wire_cst_list_prim_u_8_strict,
15075 prepare_response: wire_cst_prepare_pay_onchain_response,
15076 }
15077 #[repr(C)]
15078 #[derive(Clone, Copy)]
15079 pub struct wire_cst_payment {
15080 destination: *mut wire_cst_list_prim_u_8_strict,
15081 tx_id: *mut wire_cst_list_prim_u_8_strict,
15082 unblinding_data: *mut wire_cst_list_prim_u_8_strict,
15083 timestamp: u32,
15084 amount_sat: u64,
15085 fees_sat: u64,
15086 swapper_fees_sat: *mut u64,
15087 payment_type: i32,
15088 status: i32,
15089 details: wire_cst_payment_details,
15090 }
15091 #[repr(C)]
15092 #[derive(Clone, Copy)]
15093 pub struct wire_cst_payment_details {
15094 tag: i32,
15095 kind: PaymentDetailsKind,
15096 }
15097 #[repr(C)]
15098 #[derive(Clone, Copy)]
15099 pub union PaymentDetailsKind {
15100 Lightning: wire_cst_PaymentDetails_Lightning,
15101 Liquid: wire_cst_PaymentDetails_Liquid,
15102 Bitcoin: wire_cst_PaymentDetails_Bitcoin,
15103 nil__: (),
15104 }
15105 #[repr(C)]
15106 #[derive(Clone, Copy)]
15107 pub struct wire_cst_PaymentDetails_Lightning {
15108 swap_id: *mut wire_cst_list_prim_u_8_strict,
15109 description: *mut wire_cst_list_prim_u_8_strict,
15110 liquid_expiration_blockheight: u32,
15111 preimage: *mut wire_cst_list_prim_u_8_strict,
15112 invoice: *mut wire_cst_list_prim_u_8_strict,
15113 bolt12_offer: *mut wire_cst_list_prim_u_8_strict,
15114 payment_hash: *mut wire_cst_list_prim_u_8_strict,
15115 destination_pubkey: *mut wire_cst_list_prim_u_8_strict,
15116 lnurl_info: *mut wire_cst_ln_url_info,
15117 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15118 payer_note: *mut wire_cst_list_prim_u_8_strict,
15119 claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15120 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15121 refund_tx_amount_sat: *mut u64,
15122 }
15123 #[repr(C)]
15124 #[derive(Clone, Copy)]
15125 pub struct wire_cst_PaymentDetails_Liquid {
15126 destination: *mut wire_cst_list_prim_u_8_strict,
15127 description: *mut wire_cst_list_prim_u_8_strict,
15128 asset_id: *mut wire_cst_list_prim_u_8_strict,
15129 asset_info: *mut wire_cst_asset_info,
15130 lnurl_info: *mut wire_cst_ln_url_info,
15131 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15132 payer_note: *mut wire_cst_list_prim_u_8_strict,
15133 }
15134 #[repr(C)]
15135 #[derive(Clone, Copy)]
15136 pub struct wire_cst_PaymentDetails_Bitcoin {
15137 swap_id: *mut wire_cst_list_prim_u_8_strict,
15138 bitcoin_address: *mut wire_cst_list_prim_u_8_strict,
15139 description: *mut wire_cst_list_prim_u_8_strict,
15140 auto_accepted_fees: bool,
15141 liquid_expiration_blockheight: *mut u32,
15142 bitcoin_expiration_blockheight: *mut u32,
15143 lockup_tx_id: *mut wire_cst_list_prim_u_8_strict,
15144 claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15145 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15146 refund_tx_amount_sat: *mut u64,
15147 }
15148 #[repr(C)]
15149 #[derive(Clone, Copy)]
15150 pub struct wire_cst_payment_error {
15151 tag: i32,
15152 kind: PaymentErrorKind,
15153 }
15154 #[repr(C)]
15155 #[derive(Clone, Copy)]
15156 pub union PaymentErrorKind {
15157 AmountOutOfRange: wire_cst_PaymentError_AmountOutOfRange,
15158 AmountMissing: wire_cst_PaymentError_AmountMissing,
15159 AssetError: wire_cst_PaymentError_AssetError,
15160 InvalidNetwork: wire_cst_PaymentError_InvalidNetwork,
15161 Generic: wire_cst_PaymentError_Generic,
15162 InvalidDescription: wire_cst_PaymentError_InvalidDescription,
15163 InvalidInvoice: wire_cst_PaymentError_InvalidInvoice,
15164 ReceiveError: wire_cst_PaymentError_ReceiveError,
15165 Refunded: wire_cst_PaymentError_Refunded,
15166 SendError: wire_cst_PaymentError_SendError,
15167 SignerError: wire_cst_PaymentError_SignerError,
15168 nil__: (),
15169 }
15170 #[repr(C)]
15171 #[derive(Clone, Copy)]
15172 pub struct wire_cst_PaymentError_AmountOutOfRange {
15173 min: u64,
15174 max: u64,
15175 }
15176 #[repr(C)]
15177 #[derive(Clone, Copy)]
15178 pub struct wire_cst_PaymentError_AmountMissing {
15179 err: *mut wire_cst_list_prim_u_8_strict,
15180 }
15181 #[repr(C)]
15182 #[derive(Clone, Copy)]
15183 pub struct wire_cst_PaymentError_AssetError {
15184 err: *mut wire_cst_list_prim_u_8_strict,
15185 }
15186 #[repr(C)]
15187 #[derive(Clone, Copy)]
15188 pub struct wire_cst_PaymentError_InvalidNetwork {
15189 err: *mut wire_cst_list_prim_u_8_strict,
15190 }
15191 #[repr(C)]
15192 #[derive(Clone, Copy)]
15193 pub struct wire_cst_PaymentError_Generic {
15194 err: *mut wire_cst_list_prim_u_8_strict,
15195 }
15196 #[repr(C)]
15197 #[derive(Clone, Copy)]
15198 pub struct wire_cst_PaymentError_InvalidDescription {
15199 err: *mut wire_cst_list_prim_u_8_strict,
15200 }
15201 #[repr(C)]
15202 #[derive(Clone, Copy)]
15203 pub struct wire_cst_PaymentError_InvalidInvoice {
15204 err: *mut wire_cst_list_prim_u_8_strict,
15205 }
15206 #[repr(C)]
15207 #[derive(Clone, Copy)]
15208 pub struct wire_cst_PaymentError_ReceiveError {
15209 err: *mut wire_cst_list_prim_u_8_strict,
15210 }
15211 #[repr(C)]
15212 #[derive(Clone, Copy)]
15213 pub struct wire_cst_PaymentError_Refunded {
15214 err: *mut wire_cst_list_prim_u_8_strict,
15215 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15216 }
15217 #[repr(C)]
15218 #[derive(Clone, Copy)]
15219 pub struct wire_cst_PaymentError_SendError {
15220 err: *mut wire_cst_list_prim_u_8_strict,
15221 }
15222 #[repr(C)]
15223 #[derive(Clone, Copy)]
15224 pub struct wire_cst_PaymentError_SignerError {
15225 err: *mut wire_cst_list_prim_u_8_strict,
15226 }
15227 #[repr(C)]
15228 #[derive(Clone, Copy)]
15229 pub struct wire_cst_prepare_buy_bitcoin_request {
15230 provider: i32,
15231 amount_sat: u64,
15232 }
15233 #[repr(C)]
15234 #[derive(Clone, Copy)]
15235 pub struct wire_cst_prepare_buy_bitcoin_response {
15236 provider: i32,
15237 amount_sat: u64,
15238 fees_sat: u64,
15239 }
15240 #[repr(C)]
15241 #[derive(Clone, Copy)]
15242 pub struct wire_cst_prepare_ln_url_pay_request {
15243 data: wire_cst_ln_url_pay_request_data,
15244 amount: wire_cst_pay_amount,
15245 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15246 comment: *mut wire_cst_list_prim_u_8_strict,
15247 validate_success_action_url: *mut bool,
15248 }
15249 #[repr(C)]
15250 #[derive(Clone, Copy)]
15251 pub struct wire_cst_prepare_ln_url_pay_response {
15252 destination: wire_cst_send_destination,
15253 fees_sat: u64,
15254 data: wire_cst_ln_url_pay_request_data,
15255 amount: wire_cst_pay_amount,
15256 comment: *mut wire_cst_list_prim_u_8_strict,
15257 success_action: *mut wire_cst_success_action,
15258 }
15259 #[repr(C)]
15260 #[derive(Clone, Copy)]
15261 pub struct wire_cst_prepare_pay_onchain_request {
15262 amount: wire_cst_pay_amount,
15263 fee_rate_sat_per_vbyte: *mut u32,
15264 }
15265 #[repr(C)]
15266 #[derive(Clone, Copy)]
15267 pub struct wire_cst_prepare_pay_onchain_response {
15268 receiver_amount_sat: u64,
15269 claim_fees_sat: u64,
15270 total_fees_sat: u64,
15271 }
15272 #[repr(C)]
15273 #[derive(Clone, Copy)]
15274 pub struct wire_cst_prepare_receive_request {
15275 payment_method: i32,
15276 amount: *mut wire_cst_receive_amount,
15277 }
15278 #[repr(C)]
15279 #[derive(Clone, Copy)]
15280 pub struct wire_cst_prepare_receive_response {
15281 payment_method: i32,
15282 fees_sat: u64,
15283 amount: *mut wire_cst_receive_amount,
15284 min_payer_amount_sat: *mut u64,
15285 max_payer_amount_sat: *mut u64,
15286 swapper_feerate: *mut f64,
15287 }
15288 #[repr(C)]
15289 #[derive(Clone, Copy)]
15290 pub struct wire_cst_prepare_refund_request {
15291 swap_address: *mut wire_cst_list_prim_u_8_strict,
15292 refund_address: *mut wire_cst_list_prim_u_8_strict,
15293 fee_rate_sat_per_vbyte: u32,
15294 }
15295 #[repr(C)]
15296 #[derive(Clone, Copy)]
15297 pub struct wire_cst_prepare_refund_response {
15298 tx_vsize: u32,
15299 tx_fee_sat: u64,
15300 last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15301 }
15302 #[repr(C)]
15303 #[derive(Clone, Copy)]
15304 pub struct wire_cst_prepare_send_request {
15305 destination: *mut wire_cst_list_prim_u_8_strict,
15306 amount: *mut wire_cst_pay_amount,
15307 }
15308 #[repr(C)]
15309 #[derive(Clone, Copy)]
15310 pub struct wire_cst_prepare_send_response {
15311 destination: wire_cst_send_destination,
15312 amount: *mut wire_cst_pay_amount,
15313 fees_sat: *mut u64,
15314 estimated_asset_fees: *mut f64,
15315 }
15316 #[repr(C)]
15317 #[derive(Clone, Copy)]
15318 pub struct wire_cst_rate {
15319 coin: *mut wire_cst_list_prim_u_8_strict,
15320 value: f64,
15321 }
15322 #[repr(C)]
15323 #[derive(Clone, Copy)]
15324 pub struct wire_cst_receive_amount {
15325 tag: i32,
15326 kind: ReceiveAmountKind,
15327 }
15328 #[repr(C)]
15329 #[derive(Clone, Copy)]
15330 pub union ReceiveAmountKind {
15331 Bitcoin: wire_cst_ReceiveAmount_Bitcoin,
15332 Asset: wire_cst_ReceiveAmount_Asset,
15333 nil__: (),
15334 }
15335 #[repr(C)]
15336 #[derive(Clone, Copy)]
15337 pub struct wire_cst_ReceiveAmount_Bitcoin {
15338 payer_amount_sat: u64,
15339 }
15340 #[repr(C)]
15341 #[derive(Clone, Copy)]
15342 pub struct wire_cst_ReceiveAmount_Asset {
15343 asset_id: *mut wire_cst_list_prim_u_8_strict,
15344 payer_amount: *mut f64,
15345 }
15346 #[repr(C)]
15347 #[derive(Clone, Copy)]
15348 pub struct wire_cst_receive_payment_request {
15349 prepare_response: wire_cst_prepare_receive_response,
15350 description: *mut wire_cst_list_prim_u_8_strict,
15351 use_description_hash: *mut bool,
15352 payer_note: *mut wire_cst_list_prim_u_8_strict,
15353 }
15354 #[repr(C)]
15355 #[derive(Clone, Copy)]
15356 pub struct wire_cst_receive_payment_response {
15357 destination: *mut wire_cst_list_prim_u_8_strict,
15358 }
15359 #[repr(C)]
15360 #[derive(Clone, Copy)]
15361 pub struct wire_cst_recommended_fees {
15362 fastest_fee: u64,
15363 half_hour_fee: u64,
15364 hour_fee: u64,
15365 economy_fee: u64,
15366 minimum_fee: u64,
15367 }
15368 #[repr(C)]
15369 #[derive(Clone, Copy)]
15370 pub struct wire_cst_refund_request {
15371 swap_address: *mut wire_cst_list_prim_u_8_strict,
15372 refund_address: *mut wire_cst_list_prim_u_8_strict,
15373 fee_rate_sat_per_vbyte: u32,
15374 }
15375 #[repr(C)]
15376 #[derive(Clone, Copy)]
15377 pub struct wire_cst_refund_response {
15378 refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15379 }
15380 #[repr(C)]
15381 #[derive(Clone, Copy)]
15382 pub struct wire_cst_refundable_swap {
15383 swap_address: *mut wire_cst_list_prim_u_8_strict,
15384 timestamp: u32,
15385 amount_sat: u64,
15386 last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15387 }
15388 #[repr(C)]
15389 #[derive(Clone, Copy)]
15390 pub struct wire_cst_restore_request {
15391 backup_path: *mut wire_cst_list_prim_u_8_strict,
15392 }
15393 #[repr(C)]
15394 #[derive(Clone, Copy)]
15395 pub struct wire_cst_route_hint {
15396 hops: *mut wire_cst_list_route_hint_hop,
15397 }
15398 #[repr(C)]
15399 #[derive(Clone, Copy)]
15400 pub struct wire_cst_route_hint_hop {
15401 src_node_id: *mut wire_cst_list_prim_u_8_strict,
15402 short_channel_id: *mut wire_cst_list_prim_u_8_strict,
15403 fees_base_msat: u32,
15404 fees_proportional_millionths: u32,
15405 cltv_expiry_delta: u64,
15406 htlc_minimum_msat: *mut u64,
15407 htlc_maximum_msat: *mut u64,
15408 }
15409 #[repr(C)]
15410 #[derive(Clone, Copy)]
15411 pub struct wire_cst_sdk_error {
15412 tag: i32,
15413 kind: SdkErrorKind,
15414 }
15415 #[repr(C)]
15416 #[derive(Clone, Copy)]
15417 pub union SdkErrorKind {
15418 Generic: wire_cst_SdkError_Generic,
15419 ServiceConnectivity: wire_cst_SdkError_ServiceConnectivity,
15420 nil__: (),
15421 }
15422 #[repr(C)]
15423 #[derive(Clone, Copy)]
15424 pub struct wire_cst_SdkError_Generic {
15425 err: *mut wire_cst_list_prim_u_8_strict,
15426 }
15427 #[repr(C)]
15428 #[derive(Clone, Copy)]
15429 pub struct wire_cst_SdkError_ServiceConnectivity {
15430 err: *mut wire_cst_list_prim_u_8_strict,
15431 }
15432 #[repr(C)]
15433 #[derive(Clone, Copy)]
15434 pub struct wire_cst_sdk_event {
15435 tag: i32,
15436 kind: SdkEventKind,
15437 }
15438 #[repr(C)]
15439 #[derive(Clone, Copy)]
15440 pub union SdkEventKind {
15441 PaymentFailed: wire_cst_SdkEvent_PaymentFailed,
15442 PaymentPending: wire_cst_SdkEvent_PaymentPending,
15443 PaymentRefundable: wire_cst_SdkEvent_PaymentRefundable,
15444 PaymentRefunded: wire_cst_SdkEvent_PaymentRefunded,
15445 PaymentRefundPending: wire_cst_SdkEvent_PaymentRefundPending,
15446 PaymentSucceeded: wire_cst_SdkEvent_PaymentSucceeded,
15447 PaymentWaitingConfirmation: wire_cst_SdkEvent_PaymentWaitingConfirmation,
15448 PaymentWaitingFeeAcceptance: wire_cst_SdkEvent_PaymentWaitingFeeAcceptance,
15449 DataSynced: wire_cst_SdkEvent_DataSynced,
15450 nil__: (),
15451 }
15452 #[repr(C)]
15453 #[derive(Clone, Copy)]
15454 pub struct wire_cst_SdkEvent_PaymentFailed {
15455 details: *mut wire_cst_payment,
15456 }
15457 #[repr(C)]
15458 #[derive(Clone, Copy)]
15459 pub struct wire_cst_SdkEvent_PaymentPending {
15460 details: *mut wire_cst_payment,
15461 }
15462 #[repr(C)]
15463 #[derive(Clone, Copy)]
15464 pub struct wire_cst_SdkEvent_PaymentRefundable {
15465 details: *mut wire_cst_payment,
15466 }
15467 #[repr(C)]
15468 #[derive(Clone, Copy)]
15469 pub struct wire_cst_SdkEvent_PaymentRefunded {
15470 details: *mut wire_cst_payment,
15471 }
15472 #[repr(C)]
15473 #[derive(Clone, Copy)]
15474 pub struct wire_cst_SdkEvent_PaymentRefundPending {
15475 details: *mut wire_cst_payment,
15476 }
15477 #[repr(C)]
15478 #[derive(Clone, Copy)]
15479 pub struct wire_cst_SdkEvent_PaymentSucceeded {
15480 details: *mut wire_cst_payment,
15481 }
15482 #[repr(C)]
15483 #[derive(Clone, Copy)]
15484 pub struct wire_cst_SdkEvent_PaymentWaitingConfirmation {
15485 details: *mut wire_cst_payment,
15486 }
15487 #[repr(C)]
15488 #[derive(Clone, Copy)]
15489 pub struct wire_cst_SdkEvent_PaymentWaitingFeeAcceptance {
15490 details: *mut wire_cst_payment,
15491 }
15492 #[repr(C)]
15493 #[derive(Clone, Copy)]
15494 pub struct wire_cst_SdkEvent_DataSynced {
15495 did_pull_new_records: bool,
15496 }
15497 #[repr(C)]
15498 #[derive(Clone, Copy)]
15499 pub struct wire_cst_send_destination {
15500 tag: i32,
15501 kind: SendDestinationKind,
15502 }
15503 #[repr(C)]
15504 #[derive(Clone, Copy)]
15505 pub union SendDestinationKind {
15506 LiquidAddress: wire_cst_SendDestination_LiquidAddress,
15507 Bolt11: wire_cst_SendDestination_Bolt11,
15508 Bolt12: wire_cst_SendDestination_Bolt12,
15509 nil__: (),
15510 }
15511 #[repr(C)]
15512 #[derive(Clone, Copy)]
15513 pub struct wire_cst_SendDestination_LiquidAddress {
15514 address_data: *mut wire_cst_liquid_address_data,
15515 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15516 }
15517 #[repr(C)]
15518 #[derive(Clone, Copy)]
15519 pub struct wire_cst_SendDestination_Bolt11 {
15520 invoice: *mut wire_cst_ln_invoice,
15521 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15522 }
15523 #[repr(C)]
15524 #[derive(Clone, Copy)]
15525 pub struct wire_cst_SendDestination_Bolt12 {
15526 offer: *mut wire_cst_ln_offer,
15527 receiver_amount_sat: u64,
15528 bip353_address: *mut wire_cst_list_prim_u_8_strict,
15529 }
15530 #[repr(C)]
15531 #[derive(Clone, Copy)]
15532 pub struct wire_cst_send_payment_request {
15533 prepare_response: wire_cst_prepare_send_response,
15534 use_asset_fees: *mut bool,
15535 payer_note: *mut wire_cst_list_prim_u_8_strict,
15536 }
15537 #[repr(C)]
15538 #[derive(Clone, Copy)]
15539 pub struct wire_cst_send_payment_response {
15540 payment: wire_cst_payment,
15541 }
15542 #[repr(C)]
15543 #[derive(Clone, Copy)]
15544 pub struct wire_cst_sign_message_request {
15545 message: *mut wire_cst_list_prim_u_8_strict,
15546 }
15547 #[repr(C)]
15548 #[derive(Clone, Copy)]
15549 pub struct wire_cst_sign_message_response {
15550 signature: *mut wire_cst_list_prim_u_8_strict,
15551 }
15552 #[repr(C)]
15553 #[derive(Clone, Copy)]
15554 pub struct wire_cst_success_action {
15555 tag: i32,
15556 kind: SuccessActionKind,
15557 }
15558 #[repr(C)]
15559 #[derive(Clone, Copy)]
15560 pub union SuccessActionKind {
15561 Aes: wire_cst_SuccessAction_Aes,
15562 Message: wire_cst_SuccessAction_Message,
15563 Url: wire_cst_SuccessAction_Url,
15564 nil__: (),
15565 }
15566 #[repr(C)]
15567 #[derive(Clone, Copy)]
15568 pub struct wire_cst_SuccessAction_Aes {
15569 data: *mut wire_cst_aes_success_action_data,
15570 }
15571 #[repr(C)]
15572 #[derive(Clone, Copy)]
15573 pub struct wire_cst_SuccessAction_Message {
15574 data: *mut wire_cst_message_success_action_data,
15575 }
15576 #[repr(C)]
15577 #[derive(Clone, Copy)]
15578 pub struct wire_cst_SuccessAction_Url {
15579 data: *mut wire_cst_url_success_action_data,
15580 }
15581 #[repr(C)]
15582 #[derive(Clone, Copy)]
15583 pub struct wire_cst_success_action_processed {
15584 tag: i32,
15585 kind: SuccessActionProcessedKind,
15586 }
15587 #[repr(C)]
15588 #[derive(Clone, Copy)]
15589 pub union SuccessActionProcessedKind {
15590 Aes: wire_cst_SuccessActionProcessed_Aes,
15591 Message: wire_cst_SuccessActionProcessed_Message,
15592 Url: wire_cst_SuccessActionProcessed_Url,
15593 nil__: (),
15594 }
15595 #[repr(C)]
15596 #[derive(Clone, Copy)]
15597 pub struct wire_cst_SuccessActionProcessed_Aes {
15598 result: *mut wire_cst_aes_success_action_data_result,
15599 }
15600 #[repr(C)]
15601 #[derive(Clone, Copy)]
15602 pub struct wire_cst_SuccessActionProcessed_Message {
15603 data: *mut wire_cst_message_success_action_data,
15604 }
15605 #[repr(C)]
15606 #[derive(Clone, Copy)]
15607 pub struct wire_cst_SuccessActionProcessed_Url {
15608 data: *mut wire_cst_url_success_action_data,
15609 }
15610 #[repr(C)]
15611 #[derive(Clone, Copy)]
15612 pub struct wire_cst_symbol {
15613 grapheme: *mut wire_cst_list_prim_u_8_strict,
15614 template: *mut wire_cst_list_prim_u_8_strict,
15615 rtl: *mut bool,
15616 position: *mut u32,
15617 }
15618 #[repr(C)]
15619 #[derive(Clone, Copy)]
15620 pub struct wire_cst_url_success_action_data {
15621 description: *mut wire_cst_list_prim_u_8_strict,
15622 url: *mut wire_cst_list_prim_u_8_strict,
15623 matches_callback_domain: bool,
15624 }
15625 #[repr(C)]
15626 #[derive(Clone, Copy)]
15627 pub struct wire_cst_wallet_info {
15628 balance_sat: u64,
15629 pending_send_sat: u64,
15630 pending_receive_sat: u64,
15631 fingerprint: *mut wire_cst_list_prim_u_8_strict,
15632 pubkey: *mut wire_cst_list_prim_u_8_strict,
15633 asset_balances: *mut wire_cst_list_asset_balance,
15634 }
15635}
15636#[cfg(not(target_family = "wasm"))]
15637pub use io::*;