mirror of
https://github.com/aljazceru/breez-sdk-liquid.git
synced 2025-12-24 01:14:22 +01:00
5e2a4fe342
* Generate Dart bindings * flutter_rust_bridge has relative path issues with this new approach introduced in 2.0.0-dev.38, we'll be using the default rust_output path until it's addressed.
2374 lines
96 KiB
Rust
2374 lines
96 KiB
Rust
// This file is automatically generated, so please do not edit it.
|
|
// Generated by `flutter_rust_bridge`@ 2.0.0-dev.38.
|
|
|
|
#![allow(
|
|
non_camel_case_types,
|
|
unused,
|
|
non_snake_case,
|
|
clippy::needless_return,
|
|
clippy::redundant_closure_call,
|
|
clippy::redundant_closure,
|
|
clippy::useless_conversion,
|
|
clippy::unit_arg,
|
|
clippy::unused_unit,
|
|
clippy::double_parens,
|
|
clippy::let_and_return,
|
|
clippy::too_many_arguments,
|
|
clippy::match_single_binding,
|
|
clippy::clone_on_copy,
|
|
clippy::let_unit_value
|
|
)]
|
|
|
|
// Section: imports
|
|
|
|
use crate::bindings::*;
|
|
use crate::model::EventListener;
|
|
use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
|
|
use flutter_rust_bridge::for_generated::{transform_result_dco, Lockable};
|
|
use flutter_rust_bridge::{Handler, IntoIntoDart};
|
|
|
|
// Section: boilerplate
|
|
|
|
flutter_rust_bridge::frb_generated_boilerplate!(
|
|
default_stream_sink_codec = DcoCodec,
|
|
default_rust_opaque = RustOpaqueNom,
|
|
default_rust_auto_opaque = RustAutoOpaqueNom,
|
|
);
|
|
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.0.0-dev.38";
|
|
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 308302012;
|
|
|
|
// Section: executor
|
|
|
|
flutter_rust_bridge::frb_generated_default_handler!();
|
|
|
|
// Section: wire_funcs
|
|
|
|
fn wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
that: impl CstDecode<
|
|
RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
|
|
>,
|
|
listener: impl CstDecode<
|
|
StreamSink<crate::model::LiquidSdkEvent, flutter_rust_bridge::for_generated::DcoCodec>,
|
|
>,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "BindingLiquidSdk_add_event_listener",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let api_that = that.cst_decode();
|
|
let api_listener = listener.cst_decode();
|
|
move |context| async move {
|
|
transform_result_dco(
|
|
(move || async move {
|
|
let mut api_that_decoded = None;
|
|
let decode_indices_ =
|
|
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
|
|
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
|
|
&api_that, 0, false,
|
|
)],
|
|
);
|
|
for i in decode_indices_ {
|
|
match i {
|
|
0 => {
|
|
api_that_decoded =
|
|
Some(api_that.lockable_decode_async_ref().await)
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
let api_that = &*api_that_decoded.unwrap();
|
|
crate::bindings::BindingLiquidSdk::add_event_listener(
|
|
api_that,
|
|
api_listener,
|
|
)
|
|
.await
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__bindings__BindingLiquidSdk_backup_impl(
|
|
that: impl CstDecode<
|
|
RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
|
|
>,
|
|
req: impl CstDecode<crate::model::BackupRequest>,
|
|
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "BindingLiquidSdk_backup",
|
|
port: None,
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
|
|
},
|
|
move || {
|
|
let api_that = that.cst_decode();
|
|
let api_req = req.cst_decode();
|
|
transform_result_dco((move || {
|
|
let mut api_that_decoded = None;
|
|
let decode_indices_ =
|
|
flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
|
|
flutter_rust_bridge::for_generated::LockableOrderInfo::new(
|
|
&api_that, 0, false,
|
|
),
|
|
]);
|
|
for i in decode_indices_ {
|
|
match i {
|
|
0 => api_that_decoded = Some(api_that.lockable_decode_sync_ref()),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
let api_that = &*api_that_decoded.unwrap();
|
|
crate::bindings::BindingLiquidSdk::backup(api_that, api_req)
|
|
})())
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__bindings__BindingLiquidSdk_disconnect_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
that: impl CstDecode<
|
|
RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
|
|
>,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "BindingLiquidSdk_disconnect",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let api_that = that.cst_decode();
|
|
move |context| async move {
|
|
transform_result_dco(
|
|
(move || async move {
|
|
let mut api_that_decoded = None;
|
|
let decode_indices_ =
|
|
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
|
|
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
|
|
&api_that, 0, false,
|
|
)],
|
|
);
|
|
for i in decode_indices_ {
|
|
match i {
|
|
0 => {
|
|
api_that_decoded =
|
|
Some(api_that.lockable_decode_async_ref().await)
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
let api_that = &*api_that_decoded.unwrap();
|
|
crate::bindings::BindingLiquidSdk::disconnect(api_that).await
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(
|
|
that: impl CstDecode<
|
|
RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
|
|
>,
|
|
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "BindingLiquidSdk_empty_wallet_cache",
|
|
port: None,
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
|
|
},
|
|
move || {
|
|
let api_that = that.cst_decode();
|
|
transform_result_dco((move || {
|
|
let mut api_that_decoded = None;
|
|
let decode_indices_ =
|
|
flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
|
|
flutter_rust_bridge::for_generated::LockableOrderInfo::new(
|
|
&api_that, 0, false,
|
|
),
|
|
]);
|
|
for i in decode_indices_ {
|
|
match i {
|
|
0 => api_that_decoded = Some(api_that.lockable_decode_sync_ref()),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
let api_that = &*api_that_decoded.unwrap();
|
|
crate::bindings::BindingLiquidSdk::empty_wallet_cache(api_that)
|
|
})())
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__bindings__BindingLiquidSdk_get_info_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
that: impl CstDecode<
|
|
RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
|
|
>,
|
|
req: impl CstDecode<crate::model::GetInfoRequest>,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "BindingLiquidSdk_get_info",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let api_that = that.cst_decode();
|
|
let api_req = req.cst_decode();
|
|
move |context| async move {
|
|
transform_result_dco(
|
|
(move || async move {
|
|
let mut api_that_decoded = None;
|
|
let decode_indices_ =
|
|
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
|
|
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
|
|
&api_that, 0, false,
|
|
)],
|
|
);
|
|
for i in decode_indices_ {
|
|
match i {
|
|
0 => {
|
|
api_that_decoded =
|
|
Some(api_that.lockable_decode_async_ref().await)
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
let api_that = &*api_that_decoded.unwrap();
|
|
crate::bindings::BindingLiquidSdk::get_info(api_that, api_req).await
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__bindings__BindingLiquidSdk_list_payments_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
that: impl CstDecode<
|
|
RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
|
|
>,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "BindingLiquidSdk_list_payments",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let api_that = that.cst_decode();
|
|
move |context| async move {
|
|
transform_result_dco(
|
|
(move || async move {
|
|
let mut api_that_decoded = None;
|
|
let decode_indices_ =
|
|
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
|
|
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
|
|
&api_that, 0, false,
|
|
)],
|
|
);
|
|
for i in decode_indices_ {
|
|
match i {
|
|
0 => {
|
|
api_that_decoded =
|
|
Some(api_that.lockable_decode_async_ref().await)
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
let api_that = &*api_that_decoded.unwrap();
|
|
crate::bindings::BindingLiquidSdk::list_payments(api_that).await
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
that: impl CstDecode<
|
|
RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
|
|
>,
|
|
req: impl CstDecode<crate::model::PrepareReceiveRequest>,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "BindingLiquidSdk_prepare_receive_payment",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let api_that = that.cst_decode();
|
|
let api_req = req.cst_decode();
|
|
move |context| async move {
|
|
transform_result_dco(
|
|
(move || async move {
|
|
let mut api_that_decoded = None;
|
|
let decode_indices_ =
|
|
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
|
|
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
|
|
&api_that, 0, false,
|
|
)],
|
|
);
|
|
for i in decode_indices_ {
|
|
match i {
|
|
0 => {
|
|
api_that_decoded =
|
|
Some(api_that.lockable_decode_async_ref().await)
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
let api_that = &*api_that_decoded.unwrap();
|
|
crate::bindings::BindingLiquidSdk::prepare_receive_payment(
|
|
api_that, api_req,
|
|
)
|
|
.await
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
that: impl CstDecode<
|
|
RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
|
|
>,
|
|
req: impl CstDecode<crate::model::PrepareSendRequest>,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "BindingLiquidSdk_prepare_send_payment",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let api_that = that.cst_decode();
|
|
let api_req = req.cst_decode();
|
|
move |context| async move {
|
|
transform_result_dco(
|
|
(move || async move {
|
|
let mut api_that_decoded = None;
|
|
let decode_indices_ =
|
|
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
|
|
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
|
|
&api_that, 0, false,
|
|
)],
|
|
);
|
|
for i in decode_indices_ {
|
|
match i {
|
|
0 => {
|
|
api_that_decoded =
|
|
Some(api_that.lockable_decode_async_ref().await)
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
let api_that = &*api_that_decoded.unwrap();
|
|
crate::bindings::BindingLiquidSdk::prepare_send_payment(api_that, api_req)
|
|
.await
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
that: impl CstDecode<
|
|
RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
|
|
>,
|
|
req: impl CstDecode<crate::model::PrepareReceiveResponse>,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "BindingLiquidSdk_receive_payment",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let api_that = that.cst_decode();
|
|
let api_req = req.cst_decode();
|
|
move |context| async move {
|
|
transform_result_dco(
|
|
(move || async move {
|
|
let mut api_that_decoded = None;
|
|
let decode_indices_ =
|
|
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
|
|
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
|
|
&api_that, 0, false,
|
|
)],
|
|
);
|
|
for i in decode_indices_ {
|
|
match i {
|
|
0 => {
|
|
api_that_decoded =
|
|
Some(api_that.lockable_decode_async_ref().await)
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
let api_that = &*api_that_decoded.unwrap();
|
|
crate::bindings::BindingLiquidSdk::receive_payment(api_that, api_req).await
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__bindings__BindingLiquidSdk_restore_impl(
|
|
that: impl CstDecode<
|
|
RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
|
|
>,
|
|
req: impl CstDecode<crate::model::RestoreRequest>,
|
|
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "BindingLiquidSdk_restore",
|
|
port: None,
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
|
|
},
|
|
move || {
|
|
let api_that = that.cst_decode();
|
|
let api_req = req.cst_decode();
|
|
transform_result_dco((move || {
|
|
let mut api_that_decoded = None;
|
|
let decode_indices_ =
|
|
flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
|
|
flutter_rust_bridge::for_generated::LockableOrderInfo::new(
|
|
&api_that, 0, false,
|
|
),
|
|
]);
|
|
for i in decode_indices_ {
|
|
match i {
|
|
0 => api_that_decoded = Some(api_that.lockable_decode_sync_ref()),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
let api_that = &*api_that_decoded.unwrap();
|
|
crate::bindings::BindingLiquidSdk::restore(api_that, api_req)
|
|
})())
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__bindings__BindingLiquidSdk_send_payment_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
that: impl CstDecode<
|
|
RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
|
|
>,
|
|
req: impl CstDecode<crate::model::PrepareSendResponse>,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "BindingLiquidSdk_send_payment",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let api_that = that.cst_decode();
|
|
let api_req = req.cst_decode();
|
|
move |context| async move {
|
|
transform_result_dco(
|
|
(move || async move {
|
|
let mut api_that_decoded = None;
|
|
let decode_indices_ =
|
|
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
|
|
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
|
|
&api_that, 0, false,
|
|
)],
|
|
);
|
|
for i in decode_indices_ {
|
|
match i {
|
|
0 => {
|
|
api_that_decoded =
|
|
Some(api_that.lockable_decode_async_ref().await)
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
let api_that = &*api_that_decoded.unwrap();
|
|
crate::bindings::BindingLiquidSdk::send_payment(api_that, api_req).await
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__bindings__BindingLiquidSdk_sync_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
that: impl CstDecode<
|
|
RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
|
|
>,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "BindingLiquidSdk_sync",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let api_that = that.cst_decode();
|
|
move |context| async move {
|
|
transform_result_dco(
|
|
(move || async move {
|
|
let mut api_that_decoded = None;
|
|
let decode_indices_ =
|
|
flutter_rust_bridge::for_generated::lockable_compute_decode_order(
|
|
vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
|
|
&api_that, 0, false,
|
|
)],
|
|
);
|
|
for i in decode_indices_ {
|
|
match i {
|
|
0 => {
|
|
api_that_decoded =
|
|
Some(api_that.lockable_decode_async_ref().await)
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
let api_that = &*api_that_decoded.unwrap();
|
|
crate::bindings::BindingLiquidSdk::sync(api_that).await
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__bindings__binding_event_listener_on_event_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
that: impl CstDecode<crate::bindings::BindingEventListener>,
|
|
e: impl CstDecode<crate::model::LiquidSdkEvent>,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "binding_event_listener_on_event",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let api_that = that.cst_decode();
|
|
let api_e = e.cst_decode();
|
|
move |context| {
|
|
transform_result_dco((move || {
|
|
Result::<_, ()>::Ok({
|
|
crate::bindings::BindingEventListener::on_event(&api_that, api_e);
|
|
})
|
|
})())
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__bindings__breez_log_stream_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
s: impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec,_,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "breez_log_stream", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_s = s.cst_decode(); move |context| {
|
|
transform_result_dco((move || {
|
|
crate::bindings::breez_log_stream(api_s)
|
|
})())
|
|
} })
|
|
}
|
|
fn wire__crate__bindings__connect_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
req: impl CstDecode<crate::model::ConnectRequest>,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "connect",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let api_req = req.cst_decode();
|
|
move |context| async move {
|
|
transform_result_dco(
|
|
(move || async move { crate::bindings::connect(api_req).await })().await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__bindings__default_config_impl(
|
|
network: impl CstDecode<crate::model::Network>,
|
|
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "default_config",
|
|
port: None,
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
|
|
},
|
|
move || {
|
|
let api_network = network.cst_decode();
|
|
transform_result_dco((move || {
|
|
Result::<_, ()>::Ok(crate::bindings::default_config(api_network))
|
|
})())
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__bindings__parse_invoice_impl(
|
|
input: impl CstDecode<String>,
|
|
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "parse_invoice",
|
|
port: None,
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
|
|
},
|
|
move || {
|
|
let api_input = input.cst_decode();
|
|
transform_result_dco((move || crate::bindings::parse_invoice(api_input))())
|
|
},
|
|
)
|
|
}
|
|
|
|
// Section: dart2rust
|
|
|
|
impl CstDecode<bool> for bool {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
fn cst_decode(self) -> bool {
|
|
self
|
|
}
|
|
}
|
|
impl CstDecode<i32> for i32 {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
fn cst_decode(self) -> i32 {
|
|
self
|
|
}
|
|
}
|
|
impl CstDecode<crate::model::Network> for i32 {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
fn cst_decode(self) -> crate::model::Network {
|
|
match self {
|
|
0 => crate::model::Network::Mainnet,
|
|
1 => crate::model::Network::Testnet,
|
|
_ => unreachable!("Invalid variant for Network: {}", self),
|
|
}
|
|
}
|
|
}
|
|
impl CstDecode<crate::model::PaymentState> for i32 {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
fn cst_decode(self) -> crate::model::PaymentState {
|
|
match self {
|
|
0 => crate::model::PaymentState::Created,
|
|
1 => crate::model::PaymentState::Pending,
|
|
2 => crate::model::PaymentState::Complete,
|
|
3 => crate::model::PaymentState::Failed,
|
|
4 => crate::model::PaymentState::TimedOut,
|
|
_ => unreachable!("Invalid variant for PaymentState: {}", self),
|
|
}
|
|
}
|
|
}
|
|
impl CstDecode<crate::model::PaymentType> for i32 {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
fn cst_decode(self) -> crate::model::PaymentType {
|
|
match self {
|
|
0 => crate::model::PaymentType::Receive,
|
|
1 => crate::model::PaymentType::Send,
|
|
_ => unreachable!("Invalid variant for PaymentType: {}", self),
|
|
}
|
|
}
|
|
}
|
|
impl CstDecode<u32> for u32 {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
fn cst_decode(self) -> u32 {
|
|
self
|
|
}
|
|
}
|
|
impl CstDecode<u64> for u64 {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
fn cst_decode(self) -> u64 {
|
|
self
|
|
}
|
|
}
|
|
impl CstDecode<u8> for u8 {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
fn cst_decode(self) -> u8 {
|
|
self
|
|
}
|
|
}
|
|
impl CstDecode<usize> for usize {
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
fn cst_decode(self) -> usize {
|
|
self
|
|
}
|
|
}
|
|
impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut inner = <String>::sse_decode(deserializer);
|
|
return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
|
|
}
|
|
}
|
|
|
|
impl SseDecode for BindingLiquidSdk {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut inner = <RustOpaqueNom<
|
|
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
|
|
>>::sse_decode(deserializer);
|
|
return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
|
|
}
|
|
}
|
|
|
|
impl SseDecode
|
|
for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
|
|
{
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut inner = <usize>::sse_decode(deserializer);
|
|
return unsafe { decode_rust_opaque_nom(inner) };
|
|
}
|
|
}
|
|
|
|
impl SseDecode
|
|
for StreamSink<crate::model::LiquidSdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
|
|
{
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut inner = <String>::sse_decode(deserializer);
|
|
return StreamSink::deserialize(inner);
|
|
}
|
|
}
|
|
|
|
impl SseDecode
|
|
for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
|
|
{
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut inner = <String>::sse_decode(deserializer);
|
|
return StreamSink::deserialize(inner);
|
|
}
|
|
}
|
|
|
|
impl SseDecode for String {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut inner = <Vec<u8>>::sse_decode(deserializer);
|
|
return String::from_utf8(inner).unwrap();
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::BackupRequest {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
|
|
return crate::model::BackupRequest {
|
|
backup_path: var_backupPath,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::bindings::BindingEventListener {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_stream = <StreamSink<
|
|
crate::model::LiquidSdkEvent,
|
|
flutter_rust_bridge::for_generated::DcoCodec,
|
|
>>::sse_decode(deserializer);
|
|
return crate::bindings::BindingEventListener { stream: var_stream };
|
|
}
|
|
}
|
|
|
|
impl SseDecode for bool {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
deserializer.cursor.read_u8().unwrap() != 0
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::Config {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_boltzUrl = <String>::sse_decode(deserializer);
|
|
let mut var_electrumUrl = <String>::sse_decode(deserializer);
|
|
let mut var_workingDir = <String>::sse_decode(deserializer);
|
|
let mut var_network = <crate::model::Network>::sse_decode(deserializer);
|
|
let mut var_paymentTimeoutSec = <u64>::sse_decode(deserializer);
|
|
return crate::model::Config {
|
|
boltz_url: var_boltzUrl,
|
|
electrum_url: var_electrumUrl,
|
|
working_dir: var_workingDir,
|
|
network: var_network,
|
|
payment_timeout_sec: var_paymentTimeoutSec,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::ConnectRequest {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_mnemonic = <String>::sse_decode(deserializer);
|
|
let mut var_config = <crate::model::Config>::sse_decode(deserializer);
|
|
return crate::model::ConnectRequest {
|
|
mnemonic: var_mnemonic,
|
|
config: var_config,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::GetInfoRequest {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_withScan = <bool>::sse_decode(deserializer);
|
|
return crate::model::GetInfoRequest {
|
|
with_scan: var_withScan,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::GetInfoResponse {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_balanceSat = <u64>::sse_decode(deserializer);
|
|
let mut var_pendingSendSat = <u64>::sse_decode(deserializer);
|
|
let mut var_pendingReceiveSat = <u64>::sse_decode(deserializer);
|
|
let mut var_pubkey = <String>::sse_decode(deserializer);
|
|
return crate::model::GetInfoResponse {
|
|
balance_sat: var_balanceSat,
|
|
pending_send_sat: var_pendingSendSat,
|
|
pending_receive_sat: var_pendingReceiveSat,
|
|
pubkey: var_pubkey,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for i32 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
deserializer.cursor.read_i32::<NativeEndian>().unwrap()
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::error::LiquidSdkError {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut tag_ = <i32>::sse_decode(deserializer);
|
|
match tag_ {
|
|
0 => {
|
|
return crate::error::LiquidSdkError::AlreadyStarted;
|
|
}
|
|
1 => {
|
|
let mut var_err = <String>::sse_decode(deserializer);
|
|
return crate::error::LiquidSdkError::Generic { err: var_err };
|
|
}
|
|
2 => {
|
|
return crate::error::LiquidSdkError::NotStarted;
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::LiquidSdkEvent {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut tag_ = <i32>::sse_decode(deserializer);
|
|
match tag_ {
|
|
0 => {
|
|
let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
|
|
return crate::model::LiquidSdkEvent::PaymentFailed {
|
|
details: var_details,
|
|
};
|
|
}
|
|
1 => {
|
|
let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
|
|
return crate::model::LiquidSdkEvent::PaymentPending {
|
|
details: var_details,
|
|
};
|
|
}
|
|
2 => {
|
|
let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
|
|
return crate::model::LiquidSdkEvent::PaymentRefunded {
|
|
details: var_details,
|
|
};
|
|
}
|
|
3 => {
|
|
let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
|
|
return crate::model::LiquidSdkEvent::PaymentRefundPending {
|
|
details: var_details,
|
|
};
|
|
}
|
|
4 => {
|
|
let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
|
|
return crate::model::LiquidSdkEvent::PaymentSucceeded {
|
|
details: var_details,
|
|
};
|
|
}
|
|
5 => {
|
|
let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
|
|
return crate::model::LiquidSdkEvent::PaymentWaitingConfirmation {
|
|
details: var_details,
|
|
};
|
|
}
|
|
6 => {
|
|
return crate::model::LiquidSdkEvent::Synced;
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Vec<crate::model::Payment> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut len_ = <i32>::sse_decode(deserializer);
|
|
let mut ans_ = vec![];
|
|
for idx_ in 0..len_ {
|
|
ans_.push(<crate::model::Payment>::sse_decode(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Vec<u8> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut len_ = <i32>::sse_decode(deserializer);
|
|
let mut ans_ = vec![];
|
|
for idx_ in 0..len_ {
|
|
ans_.push(<u8>::sse_decode(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Vec<crate::model::RouteHint> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut len_ = <i32>::sse_decode(deserializer);
|
|
let mut ans_ = vec![];
|
|
for idx_ in 0..len_ {
|
|
ans_.push(<crate::model::RouteHint>::sse_decode(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Vec<crate::model::RouteHintHop> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut len_ = <i32>::sse_decode(deserializer);
|
|
let mut ans_ = vec![];
|
|
for idx_ in 0..len_ {
|
|
ans_.push(<crate::model::RouteHintHop>::sse_decode(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::LNInvoice {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_bolt11 = <String>::sse_decode(deserializer);
|
|
let mut var_network = <crate::model::Network>::sse_decode(deserializer);
|
|
let mut var_payeePubkey = <String>::sse_decode(deserializer);
|
|
let mut var_paymentHash = <String>::sse_decode(deserializer);
|
|
let mut var_description = <Option<String>>::sse_decode(deserializer);
|
|
let mut var_descriptionHash = <Option<String>>::sse_decode(deserializer);
|
|
let mut var_amountMsat = <Option<u64>>::sse_decode(deserializer);
|
|
let mut var_timestamp = <u64>::sse_decode(deserializer);
|
|
let mut var_expiry = <u64>::sse_decode(deserializer);
|
|
let mut var_routingHints = <Vec<crate::model::RouteHint>>::sse_decode(deserializer);
|
|
let mut var_paymentSecret = <Vec<u8>>::sse_decode(deserializer);
|
|
let mut var_minFinalCltvExpiryDelta = <u64>::sse_decode(deserializer);
|
|
return crate::model::LNInvoice {
|
|
bolt11: var_bolt11,
|
|
network: var_network,
|
|
payee_pubkey: var_payeePubkey,
|
|
payment_hash: var_paymentHash,
|
|
description: var_description,
|
|
description_hash: var_descriptionHash,
|
|
amount_msat: var_amountMsat,
|
|
timestamp: var_timestamp,
|
|
expiry: var_expiry,
|
|
routing_hints: var_routingHints,
|
|
payment_secret: var_paymentSecret,
|
|
min_final_cltv_expiry_delta: var_minFinalCltvExpiryDelta,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::LogEntry {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_line = <String>::sse_decode(deserializer);
|
|
let mut var_level = <String>::sse_decode(deserializer);
|
|
return crate::model::LogEntry {
|
|
line: var_line,
|
|
level: var_level,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::Network {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut inner = <i32>::sse_decode(deserializer);
|
|
return match inner {
|
|
0 => crate::model::Network::Mainnet,
|
|
1 => crate::model::Network::Testnet,
|
|
_ => unreachable!("Invalid variant for Network: {}", inner),
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Option<String> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
if (<bool>::sse_decode(deserializer)) {
|
|
return Some(<String>::sse_decode(deserializer));
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Option<u64> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
if (<bool>::sse_decode(deserializer)) {
|
|
return Some(<u64>::sse_decode(deserializer));
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::Payment {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_txId = <String>::sse_decode(deserializer);
|
|
let mut var_swapId = <Option<String>>::sse_decode(deserializer);
|
|
let mut var_timestamp = <u32>::sse_decode(deserializer);
|
|
let mut var_amountSat = <u64>::sse_decode(deserializer);
|
|
let mut var_feesSat = <u64>::sse_decode(deserializer);
|
|
let mut var_preimage = <Option<String>>::sse_decode(deserializer);
|
|
let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
|
|
let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
|
|
let mut var_paymentType = <crate::model::PaymentType>::sse_decode(deserializer);
|
|
let mut var_status = <crate::model::PaymentState>::sse_decode(deserializer);
|
|
return crate::model::Payment {
|
|
tx_id: var_txId,
|
|
swap_id: var_swapId,
|
|
timestamp: var_timestamp,
|
|
amount_sat: var_amountSat,
|
|
fees_sat: var_feesSat,
|
|
preimage: var_preimage,
|
|
refund_tx_id: var_refundTxId,
|
|
refund_tx_amount_sat: var_refundTxAmountSat,
|
|
payment_type: var_paymentType,
|
|
status: var_status,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::error::PaymentError {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut tag_ = <i32>::sse_decode(deserializer);
|
|
match tag_ {
|
|
0 => {
|
|
return crate::error::PaymentError::AlreadyClaimed;
|
|
}
|
|
1 => {
|
|
return crate::error::PaymentError::AlreadyPaid;
|
|
}
|
|
2 => {
|
|
return crate::error::PaymentError::PaymentInProgress;
|
|
}
|
|
3 => {
|
|
return crate::error::PaymentError::AmountOutOfRange;
|
|
}
|
|
4 => {
|
|
let mut var_err = <String>::sse_decode(deserializer);
|
|
return crate::error::PaymentError::Generic { err: var_err };
|
|
}
|
|
5 => {
|
|
return crate::error::PaymentError::InvalidOrExpiredFees;
|
|
}
|
|
6 => {
|
|
return crate::error::PaymentError::InsufficientFunds;
|
|
}
|
|
7 => {
|
|
let mut var_err = <String>::sse_decode(deserializer);
|
|
return crate::error::PaymentError::InvalidInvoice { err: var_err };
|
|
}
|
|
8 => {
|
|
return crate::error::PaymentError::InvalidPreimage;
|
|
}
|
|
9 => {
|
|
let mut var_err = <String>::sse_decode(deserializer);
|
|
return crate::error::PaymentError::LwkError { err: var_err };
|
|
}
|
|
10 => {
|
|
return crate::error::PaymentError::PairsNotFound;
|
|
}
|
|
11 => {
|
|
return crate::error::PaymentError::PaymentTimeout;
|
|
}
|
|
12 => {
|
|
return crate::error::PaymentError::PersistError;
|
|
}
|
|
13 => {
|
|
let mut var_err = <String>::sse_decode(deserializer);
|
|
return crate::error::PaymentError::ReceiveError { err: var_err };
|
|
}
|
|
14 => {
|
|
let mut var_err = <String>::sse_decode(deserializer);
|
|
let mut var_refundTxId = <String>::sse_decode(deserializer);
|
|
return crate::error::PaymentError::Refunded {
|
|
err: var_err,
|
|
refund_tx_id: var_refundTxId,
|
|
};
|
|
}
|
|
15 => {
|
|
return crate::error::PaymentError::SelfTransferNotSupported;
|
|
}
|
|
16 => {
|
|
let mut var_err = <String>::sse_decode(deserializer);
|
|
return crate::error::PaymentError::SendError { err: var_err };
|
|
}
|
|
17 => {
|
|
let mut var_err = <String>::sse_decode(deserializer);
|
|
return crate::error::PaymentError::SignerError { err: var_err };
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::PaymentState {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut inner = <i32>::sse_decode(deserializer);
|
|
return match inner {
|
|
0 => crate::model::PaymentState::Created,
|
|
1 => crate::model::PaymentState::Pending,
|
|
2 => crate::model::PaymentState::Complete,
|
|
3 => crate::model::PaymentState::Failed,
|
|
4 => crate::model::PaymentState::TimedOut,
|
|
_ => unreachable!("Invalid variant for PaymentState: {}", inner),
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::PaymentType {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut inner = <i32>::sse_decode(deserializer);
|
|
return match inner {
|
|
0 => crate::model::PaymentType::Receive,
|
|
1 => crate::model::PaymentType::Send,
|
|
_ => unreachable!("Invalid variant for PaymentType: {}", inner),
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::PrepareReceiveRequest {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
|
|
return crate::model::PrepareReceiveRequest {
|
|
payer_amount_sat: var_payerAmountSat,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::PrepareReceiveResponse {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
|
|
let mut var_feesSat = <u64>::sse_decode(deserializer);
|
|
return crate::model::PrepareReceiveResponse {
|
|
payer_amount_sat: var_payerAmountSat,
|
|
fees_sat: var_feesSat,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::PrepareSendRequest {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_invoice = <String>::sse_decode(deserializer);
|
|
return crate::model::PrepareSendRequest {
|
|
invoice: var_invoice,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::PrepareSendResponse {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_invoice = <String>::sse_decode(deserializer);
|
|
let mut var_feesSat = <u64>::sse_decode(deserializer);
|
|
return crate::model::PrepareSendResponse {
|
|
invoice: var_invoice,
|
|
fees_sat: var_feesSat,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::ReceivePaymentResponse {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_id = <String>::sse_decode(deserializer);
|
|
let mut var_invoice = <String>::sse_decode(deserializer);
|
|
return crate::model::ReceivePaymentResponse {
|
|
id: var_id,
|
|
invoice: var_invoice,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::RestoreRequest {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
|
|
return crate::model::RestoreRequest {
|
|
backup_path: var_backupPath,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::RouteHint {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_hops = <Vec<crate::model::RouteHintHop>>::sse_decode(deserializer);
|
|
return crate::model::RouteHint { hops: var_hops };
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::RouteHintHop {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_srcNodeId = <String>::sse_decode(deserializer);
|
|
let mut var_shortChannelId = <u64>::sse_decode(deserializer);
|
|
let mut var_feesBaseMsat = <u32>::sse_decode(deserializer);
|
|
let mut var_feesProportionalMillionths = <u32>::sse_decode(deserializer);
|
|
let mut var_cltvExpiryDelta = <u64>::sse_decode(deserializer);
|
|
let mut var_htlcMinimumMsat = <Option<u64>>::sse_decode(deserializer);
|
|
let mut var_htlcMaximumMsat = <Option<u64>>::sse_decode(deserializer);
|
|
return crate::model::RouteHintHop {
|
|
src_node_id: var_srcNodeId,
|
|
short_channel_id: var_shortChannelId,
|
|
fees_base_msat: var_feesBaseMsat,
|
|
fees_proportional_millionths: var_feesProportionalMillionths,
|
|
cltv_expiry_delta: var_cltvExpiryDelta,
|
|
htlc_minimum_msat: var_htlcMinimumMsat,
|
|
htlc_maximum_msat: var_htlcMaximumMsat,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::model::SendPaymentResponse {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
|
|
return crate::model::SendPaymentResponse {
|
|
payment: var_payment,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for u32 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
deserializer.cursor.read_u32::<NativeEndian>().unwrap()
|
|
}
|
|
}
|
|
|
|
impl SseDecode for u64 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
deserializer.cursor.read_u64::<NativeEndian>().unwrap()
|
|
}
|
|
}
|
|
|
|
impl SseDecode for u8 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
deserializer.cursor.read_u8().unwrap()
|
|
}
|
|
}
|
|
|
|
impl SseDecode for () {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
|
|
}
|
|
|
|
impl SseDecode for usize {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
|
|
}
|
|
}
|
|
|
|
fn pde_ffi_dispatcher_primary_impl(
|
|
func_id: i32,
|
|
port: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len: i32,
|
|
data_len: i32,
|
|
) {
|
|
// Codec=Pde (Serialization + dispatch), see doc to use other codecs
|
|
match func_id {
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn pde_ffi_dispatcher_sync_impl(
|
|
func_id: i32,
|
|
ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len: i32,
|
|
data_len: i32,
|
|
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
|
|
// Codec=Pde (Serialization + dispatch), see doc to use other codecs
|
|
match func_id {
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
// Section: rust2dart
|
|
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for FrbWrapper<BindingLiquidSdk> {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0)
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<BindingLiquidSdk> {}
|
|
|
|
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<BindingLiquidSdk>> for BindingLiquidSdk {
|
|
fn into_into_dart(self) -> FrbWrapper<BindingLiquidSdk> {
|
|
self.into()
|
|
}
|
|
}
|
|
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::BackupRequest {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[self.backup_path.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BackupRequest {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::BackupRequest>
|
|
for crate::model::BackupRequest
|
|
{
|
|
fn into_into_dart(self) -> crate::model::BackupRequest {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::bindings::BindingEventListener {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[self.stream.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::bindings::BindingEventListener
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::bindings::BindingEventListener>
|
|
for crate::bindings::BindingEventListener
|
|
{
|
|
fn into_into_dart(self) -> crate::bindings::BindingEventListener {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::Config {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.boltz_url.into_into_dart().into_dart(),
|
|
self.electrum_url.into_into_dart().into_dart(),
|
|
self.working_dir.into_into_dart().into_dart(),
|
|
self.network.into_into_dart().into_dart(),
|
|
self.payment_timeout_sec.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Config {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::Config> for crate::model::Config {
|
|
fn into_into_dart(self) -> crate::model::Config {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::ConnectRequest {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.mnemonic.into_into_dart().into_dart(),
|
|
self.config.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ConnectRequest {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::ConnectRequest>
|
|
for crate::model::ConnectRequest
|
|
{
|
|
fn into_into_dart(self) -> crate::model::ConnectRequest {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::GetInfoRequest {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[self.with_scan.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::GetInfoRequest {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::GetInfoRequest>
|
|
for crate::model::GetInfoRequest
|
|
{
|
|
fn into_into_dart(self) -> crate::model::GetInfoRequest {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::GetInfoResponse {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.balance_sat.into_into_dart().into_dart(),
|
|
self.pending_send_sat.into_into_dart().into_dart(),
|
|
self.pending_receive_sat.into_into_dart().into_dart(),
|
|
self.pubkey.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::GetInfoResponse {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::GetInfoResponse>
|
|
for crate::model::GetInfoResponse
|
|
{
|
|
fn into_into_dart(self) -> crate::model::GetInfoResponse {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::error::LiquidSdkError {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
crate::error::LiquidSdkError::AlreadyStarted => [0.into_dart()].into_dart(),
|
|
crate::error::LiquidSdkError::Generic { err } => {
|
|
[1.into_dart(), err.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::error::LiquidSdkError::NotStarted => [2.into_dart()].into_dart(),
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::LiquidSdkError {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::error::LiquidSdkError>
|
|
for crate::error::LiquidSdkError
|
|
{
|
|
fn into_into_dart(self) -> crate::error::LiquidSdkError {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::LiquidSdkEvent {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
crate::model::LiquidSdkEvent::PaymentFailed { details } => {
|
|
[0.into_dart(), details.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::model::LiquidSdkEvent::PaymentPending { details } => {
|
|
[1.into_dart(), details.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::model::LiquidSdkEvent::PaymentRefunded { details } => {
|
|
[2.into_dart(), details.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::model::LiquidSdkEvent::PaymentRefundPending { details } => {
|
|
[3.into_dart(), details.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::model::LiquidSdkEvent::PaymentSucceeded { details } => {
|
|
[4.into_dart(), details.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::model::LiquidSdkEvent::PaymentWaitingConfirmation { details } => {
|
|
[5.into_dart(), details.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::model::LiquidSdkEvent::Synced => [6.into_dart()].into_dart(),
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LiquidSdkEvent {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::LiquidSdkEvent>
|
|
for crate::model::LiquidSdkEvent
|
|
{
|
|
fn into_into_dart(self) -> crate::model::LiquidSdkEvent {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::LNInvoice {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.bolt11.into_into_dart().into_dart(),
|
|
self.network.into_into_dart().into_dart(),
|
|
self.payee_pubkey.into_into_dart().into_dart(),
|
|
self.payment_hash.into_into_dart().into_dart(),
|
|
self.description.into_into_dart().into_dart(),
|
|
self.description_hash.into_into_dart().into_dart(),
|
|
self.amount_msat.into_into_dart().into_dart(),
|
|
self.timestamp.into_into_dart().into_dart(),
|
|
self.expiry.into_into_dart().into_dart(),
|
|
self.routing_hints.into_into_dart().into_dart(),
|
|
self.payment_secret.into_into_dart().into_dart(),
|
|
self.min_final_cltv_expiry_delta
|
|
.into_into_dart()
|
|
.into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LNInvoice {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::LNInvoice> for crate::model::LNInvoice {
|
|
fn into_into_dart(self) -> crate::model::LNInvoice {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::LogEntry {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.line.into_into_dart().into_dart(),
|
|
self.level.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LogEntry {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::LogEntry> for crate::model::LogEntry {
|
|
fn into_into_dart(self) -> crate::model::LogEntry {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::Network {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
Self::Mainnet => 0.into_dart(),
|
|
Self::Testnet => 1.into_dart(),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Network {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::Network> for crate::model::Network {
|
|
fn into_into_dart(self) -> crate::model::Network {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::Payment {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.tx_id.into_into_dart().into_dart(),
|
|
self.swap_id.into_into_dart().into_dart(),
|
|
self.timestamp.into_into_dart().into_dart(),
|
|
self.amount_sat.into_into_dart().into_dart(),
|
|
self.fees_sat.into_into_dart().into_dart(),
|
|
self.preimage.into_into_dart().into_dart(),
|
|
self.refund_tx_id.into_into_dart().into_dart(),
|
|
self.refund_tx_amount_sat.into_into_dart().into_dart(),
|
|
self.payment_type.into_into_dart().into_dart(),
|
|
self.status.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Payment {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::Payment> for crate::model::Payment {
|
|
fn into_into_dart(self) -> crate::model::Payment {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::error::PaymentError {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
crate::error::PaymentError::AlreadyClaimed => [0.into_dart()].into_dart(),
|
|
crate::error::PaymentError::AlreadyPaid => [1.into_dart()].into_dart(),
|
|
crate::error::PaymentError::PaymentInProgress => [2.into_dart()].into_dart(),
|
|
crate::error::PaymentError::AmountOutOfRange => [3.into_dart()].into_dart(),
|
|
crate::error::PaymentError::Generic { err } => {
|
|
[4.into_dart(), err.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::error::PaymentError::InvalidOrExpiredFees => [5.into_dart()].into_dart(),
|
|
crate::error::PaymentError::InsufficientFunds => [6.into_dart()].into_dart(),
|
|
crate::error::PaymentError::InvalidInvoice { err } => {
|
|
[7.into_dart(), err.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::error::PaymentError::InvalidPreimage => [8.into_dart()].into_dart(),
|
|
crate::error::PaymentError::LwkError { err } => {
|
|
[9.into_dart(), err.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::error::PaymentError::PairsNotFound => [10.into_dart()].into_dart(),
|
|
crate::error::PaymentError::PaymentTimeout => [11.into_dart()].into_dart(),
|
|
crate::error::PaymentError::PersistError => [12.into_dart()].into_dart(),
|
|
crate::error::PaymentError::ReceiveError { err } => {
|
|
[13.into_dart(), err.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::error::PaymentError::Refunded { err, refund_tx_id } => [
|
|
14.into_dart(),
|
|
err.into_into_dart().into_dart(),
|
|
refund_tx_id.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart(),
|
|
crate::error::PaymentError::SelfTransferNotSupported => [15.into_dart()].into_dart(),
|
|
crate::error::PaymentError::SendError { err } => {
|
|
[16.into_dart(), err.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::error::PaymentError::SignerError { err } => {
|
|
[17.into_dart(), err.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::PaymentError {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::error::PaymentError> for crate::error::PaymentError {
|
|
fn into_into_dart(self) -> crate::error::PaymentError {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::PaymentState {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
Self::Created => 0.into_dart(),
|
|
Self::Pending => 1.into_dart(),
|
|
Self::Complete => 2.into_dart(),
|
|
Self::Failed => 3.into_dart(),
|
|
Self::TimedOut => 4.into_dart(),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentState {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentState> for crate::model::PaymentState {
|
|
fn into_into_dart(self) -> crate::model::PaymentState {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::PaymentType {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
Self::Receive => 0.into_dart(),
|
|
Self::Send => 1.into_dart(),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentType {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentType> for crate::model::PaymentType {
|
|
fn into_into_dart(self) -> crate::model::PaymentType {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveRequest {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[self.payer_amount_sat.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::model::PrepareReceiveRequest
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveRequest>
|
|
for crate::model::PrepareReceiveRequest
|
|
{
|
|
fn into_into_dart(self) -> crate::model::PrepareReceiveRequest {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveResponse {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.payer_amount_sat.into_into_dart().into_dart(),
|
|
self.fees_sat.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::model::PrepareReceiveResponse
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveResponse>
|
|
for crate::model::PrepareReceiveResponse
|
|
{
|
|
fn into_into_dart(self) -> crate::model::PrepareReceiveResponse {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendRequest {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[self.invoice.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::model::PrepareSendRequest
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendRequest>
|
|
for crate::model::PrepareSendRequest
|
|
{
|
|
fn into_into_dart(self) -> crate::model::PrepareSendRequest {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendResponse {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.invoice.into_into_dart().into_dart(),
|
|
self.fees_sat.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::model::PrepareSendResponse
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendResponse>
|
|
for crate::model::PrepareSendResponse
|
|
{
|
|
fn into_into_dart(self) -> crate::model::PrepareSendResponse {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentResponse {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.id.into_into_dart().into_dart(),
|
|
self.invoice.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::model::ReceivePaymentResponse
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentResponse>
|
|
for crate::model::ReceivePaymentResponse
|
|
{
|
|
fn into_into_dart(self) -> crate::model::ReceivePaymentResponse {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::RestoreRequest {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[self.backup_path.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RestoreRequest {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::RestoreRequest>
|
|
for crate::model::RestoreRequest
|
|
{
|
|
fn into_into_dart(self) -> crate::model::RestoreRequest {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::RouteHint {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[self.hops.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RouteHint {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::RouteHint> for crate::model::RouteHint {
|
|
fn into_into_dart(self) -> crate::model::RouteHint {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::RouteHintHop {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.src_node_id.into_into_dart().into_dart(),
|
|
self.short_channel_id.into_into_dart().into_dart(),
|
|
self.fees_base_msat.into_into_dart().into_dart(),
|
|
self.fees_proportional_millionths
|
|
.into_into_dart()
|
|
.into_dart(),
|
|
self.cltv_expiry_delta.into_into_dart().into_dart(),
|
|
self.htlc_minimum_msat.into_into_dart().into_dart(),
|
|
self.htlc_maximum_msat.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RouteHintHop {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::RouteHintHop> for crate::model::RouteHintHop {
|
|
fn into_into_dart(self) -> crate::model::RouteHintHop {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentResponse {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[self.payment.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::model::SendPaymentResponse
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentResponse>
|
|
for crate::model::SendPaymentResponse
|
|
{
|
|
fn into_into_dart(self) -> crate::model::SendPaymentResponse {
|
|
self
|
|
}
|
|
}
|
|
|
|
impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<String>::sse_encode(format!("{:?}", self), serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for BindingLiquidSdk {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode
|
|
for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
|
|
{
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
let (ptr, size) = self.sse_encode_raw();
|
|
<usize>::sse_encode(ptr, serializer);
|
|
<i32>::sse_encode(size, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode
|
|
for StreamSink<crate::model::LiquidSdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
|
|
{
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
unimplemented!("")
|
|
}
|
|
}
|
|
|
|
impl SseEncode
|
|
for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
|
|
{
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
unimplemented!("")
|
|
}
|
|
}
|
|
|
|
impl SseEncode for String {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<Vec<u8>>::sse_encode(self.into_bytes(), serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::BackupRequest {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<Option<String>>::sse_encode(self.backup_path, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::bindings::BindingEventListener {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<StreamSink<crate::model::LiquidSdkEvent,flutter_rust_bridge::for_generated::DcoCodec>>::sse_encode(self.stream, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for bool {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
serializer.cursor.write_u8(self as _).unwrap();
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::Config {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<String>::sse_encode(self.boltz_url, serializer);
|
|
<String>::sse_encode(self.electrum_url, serializer);
|
|
<String>::sse_encode(self.working_dir, serializer);
|
|
<crate::model::Network>::sse_encode(self.network, serializer);
|
|
<u64>::sse_encode(self.payment_timeout_sec, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::ConnectRequest {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<String>::sse_encode(self.mnemonic, serializer);
|
|
<crate::model::Config>::sse_encode(self.config, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::GetInfoRequest {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<bool>::sse_encode(self.with_scan, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::GetInfoResponse {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<u64>::sse_encode(self.balance_sat, serializer);
|
|
<u64>::sse_encode(self.pending_send_sat, serializer);
|
|
<u64>::sse_encode(self.pending_receive_sat, serializer);
|
|
<String>::sse_encode(self.pubkey, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for i32 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::error::LiquidSdkError {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
match self {
|
|
crate::error::LiquidSdkError::AlreadyStarted => {
|
|
<i32>::sse_encode(0, serializer);
|
|
}
|
|
crate::error::LiquidSdkError::Generic { err } => {
|
|
<i32>::sse_encode(1, serializer);
|
|
<String>::sse_encode(err, serializer);
|
|
}
|
|
crate::error::LiquidSdkError::NotStarted => {
|
|
<i32>::sse_encode(2, serializer);
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::LiquidSdkEvent {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
match self {
|
|
crate::model::LiquidSdkEvent::PaymentFailed { details } => {
|
|
<i32>::sse_encode(0, serializer);
|
|
<crate::model::Payment>::sse_encode(details, serializer);
|
|
}
|
|
crate::model::LiquidSdkEvent::PaymentPending { details } => {
|
|
<i32>::sse_encode(1, serializer);
|
|
<crate::model::Payment>::sse_encode(details, serializer);
|
|
}
|
|
crate::model::LiquidSdkEvent::PaymentRefunded { details } => {
|
|
<i32>::sse_encode(2, serializer);
|
|
<crate::model::Payment>::sse_encode(details, serializer);
|
|
}
|
|
crate::model::LiquidSdkEvent::PaymentRefundPending { details } => {
|
|
<i32>::sse_encode(3, serializer);
|
|
<crate::model::Payment>::sse_encode(details, serializer);
|
|
}
|
|
crate::model::LiquidSdkEvent::PaymentSucceeded { details } => {
|
|
<i32>::sse_encode(4, serializer);
|
|
<crate::model::Payment>::sse_encode(details, serializer);
|
|
}
|
|
crate::model::LiquidSdkEvent::PaymentWaitingConfirmation { details } => {
|
|
<i32>::sse_encode(5, serializer);
|
|
<crate::model::Payment>::sse_encode(details, serializer);
|
|
}
|
|
crate::model::LiquidSdkEvent::Synced => {
|
|
<i32>::sse_encode(6, serializer);
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Vec<crate::model::Payment> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i32>::sse_encode(self.len() as _, serializer);
|
|
for item in self {
|
|
<crate::model::Payment>::sse_encode(item, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Vec<u8> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i32>::sse_encode(self.len() as _, serializer);
|
|
for item in self {
|
|
<u8>::sse_encode(item, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Vec<crate::model::RouteHint> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i32>::sse_encode(self.len() as _, serializer);
|
|
for item in self {
|
|
<crate::model::RouteHint>::sse_encode(item, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Vec<crate::model::RouteHintHop> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i32>::sse_encode(self.len() as _, serializer);
|
|
for item in self {
|
|
<crate::model::RouteHintHop>::sse_encode(item, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::LNInvoice {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<String>::sse_encode(self.bolt11, serializer);
|
|
<crate::model::Network>::sse_encode(self.network, serializer);
|
|
<String>::sse_encode(self.payee_pubkey, serializer);
|
|
<String>::sse_encode(self.payment_hash, serializer);
|
|
<Option<String>>::sse_encode(self.description, serializer);
|
|
<Option<String>>::sse_encode(self.description_hash, serializer);
|
|
<Option<u64>>::sse_encode(self.amount_msat, serializer);
|
|
<u64>::sse_encode(self.timestamp, serializer);
|
|
<u64>::sse_encode(self.expiry, serializer);
|
|
<Vec<crate::model::RouteHint>>::sse_encode(self.routing_hints, serializer);
|
|
<Vec<u8>>::sse_encode(self.payment_secret, serializer);
|
|
<u64>::sse_encode(self.min_final_cltv_expiry_delta, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::LogEntry {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<String>::sse_encode(self.line, serializer);
|
|
<String>::sse_encode(self.level, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::Network {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i32>::sse_encode(
|
|
match self {
|
|
crate::model::Network::Mainnet => 0,
|
|
crate::model::Network::Testnet => 1,
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
},
|
|
serializer,
|
|
);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Option<String> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<bool>::sse_encode(self.is_some(), serializer);
|
|
if let Some(value) = self {
|
|
<String>::sse_encode(value, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Option<u64> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<bool>::sse_encode(self.is_some(), serializer);
|
|
if let Some(value) = self {
|
|
<u64>::sse_encode(value, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::Payment {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<String>::sse_encode(self.tx_id, serializer);
|
|
<Option<String>>::sse_encode(self.swap_id, serializer);
|
|
<u32>::sse_encode(self.timestamp, serializer);
|
|
<u64>::sse_encode(self.amount_sat, serializer);
|
|
<u64>::sse_encode(self.fees_sat, serializer);
|
|
<Option<String>>::sse_encode(self.preimage, serializer);
|
|
<Option<String>>::sse_encode(self.refund_tx_id, serializer);
|
|
<Option<u64>>::sse_encode(self.refund_tx_amount_sat, serializer);
|
|
<crate::model::PaymentType>::sse_encode(self.payment_type, serializer);
|
|
<crate::model::PaymentState>::sse_encode(self.status, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::error::PaymentError {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
match self {
|
|
crate::error::PaymentError::AlreadyClaimed => {
|
|
<i32>::sse_encode(0, serializer);
|
|
}
|
|
crate::error::PaymentError::AlreadyPaid => {
|
|
<i32>::sse_encode(1, serializer);
|
|
}
|
|
crate::error::PaymentError::PaymentInProgress => {
|
|
<i32>::sse_encode(2, serializer);
|
|
}
|
|
crate::error::PaymentError::AmountOutOfRange => {
|
|
<i32>::sse_encode(3, serializer);
|
|
}
|
|
crate::error::PaymentError::Generic { err } => {
|
|
<i32>::sse_encode(4, serializer);
|
|
<String>::sse_encode(err, serializer);
|
|
}
|
|
crate::error::PaymentError::InvalidOrExpiredFees => {
|
|
<i32>::sse_encode(5, serializer);
|
|
}
|
|
crate::error::PaymentError::InsufficientFunds => {
|
|
<i32>::sse_encode(6, serializer);
|
|
}
|
|
crate::error::PaymentError::InvalidInvoice { err } => {
|
|
<i32>::sse_encode(7, serializer);
|
|
<String>::sse_encode(err, serializer);
|
|
}
|
|
crate::error::PaymentError::InvalidPreimage => {
|
|
<i32>::sse_encode(8, serializer);
|
|
}
|
|
crate::error::PaymentError::LwkError { err } => {
|
|
<i32>::sse_encode(9, serializer);
|
|
<String>::sse_encode(err, serializer);
|
|
}
|
|
crate::error::PaymentError::PairsNotFound => {
|
|
<i32>::sse_encode(10, serializer);
|
|
}
|
|
crate::error::PaymentError::PaymentTimeout => {
|
|
<i32>::sse_encode(11, serializer);
|
|
}
|
|
crate::error::PaymentError::PersistError => {
|
|
<i32>::sse_encode(12, serializer);
|
|
}
|
|
crate::error::PaymentError::ReceiveError { err } => {
|
|
<i32>::sse_encode(13, serializer);
|
|
<String>::sse_encode(err, serializer);
|
|
}
|
|
crate::error::PaymentError::Refunded { err, refund_tx_id } => {
|
|
<i32>::sse_encode(14, serializer);
|
|
<String>::sse_encode(err, serializer);
|
|
<String>::sse_encode(refund_tx_id, serializer);
|
|
}
|
|
crate::error::PaymentError::SelfTransferNotSupported => {
|
|
<i32>::sse_encode(15, serializer);
|
|
}
|
|
crate::error::PaymentError::SendError { err } => {
|
|
<i32>::sse_encode(16, serializer);
|
|
<String>::sse_encode(err, serializer);
|
|
}
|
|
crate::error::PaymentError::SignerError { err } => {
|
|
<i32>::sse_encode(17, serializer);
|
|
<String>::sse_encode(err, serializer);
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::PaymentState {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i32>::sse_encode(
|
|
match self {
|
|
crate::model::PaymentState::Created => 0,
|
|
crate::model::PaymentState::Pending => 1,
|
|
crate::model::PaymentState::Complete => 2,
|
|
crate::model::PaymentState::Failed => 3,
|
|
crate::model::PaymentState::TimedOut => 4,
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
},
|
|
serializer,
|
|
);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::PaymentType {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i32>::sse_encode(
|
|
match self {
|
|
crate::model::PaymentType::Receive => 0,
|
|
crate::model::PaymentType::Send => 1,
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
},
|
|
serializer,
|
|
);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::PrepareReceiveRequest {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<u64>::sse_encode(self.payer_amount_sat, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::PrepareReceiveResponse {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<u64>::sse_encode(self.payer_amount_sat, serializer);
|
|
<u64>::sse_encode(self.fees_sat, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::PrepareSendRequest {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<String>::sse_encode(self.invoice, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::PrepareSendResponse {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<String>::sse_encode(self.invoice, serializer);
|
|
<u64>::sse_encode(self.fees_sat, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::ReceivePaymentResponse {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<String>::sse_encode(self.id, serializer);
|
|
<String>::sse_encode(self.invoice, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::RestoreRequest {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<Option<String>>::sse_encode(self.backup_path, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::RouteHint {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<Vec<crate::model::RouteHintHop>>::sse_encode(self.hops, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::RouteHintHop {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<String>::sse_encode(self.src_node_id, serializer);
|
|
<u64>::sse_encode(self.short_channel_id, serializer);
|
|
<u32>::sse_encode(self.fees_base_msat, serializer);
|
|
<u32>::sse_encode(self.fees_proportional_millionths, serializer);
|
|
<u64>::sse_encode(self.cltv_expiry_delta, serializer);
|
|
<Option<u64>>::sse_encode(self.htlc_minimum_msat, serializer);
|
|
<Option<u64>>::sse_encode(self.htlc_maximum_msat, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::model::SendPaymentResponse {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<crate::model::Payment>::sse_encode(self.payment, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for u32 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
|
|
}
|
|
}
|
|
|
|
impl SseEncode for u64 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
|
|
}
|
|
}
|
|
|
|
impl SseEncode for u8 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
serializer.cursor.write_u8(self).unwrap();
|
|
}
|
|
}
|
|
|
|
impl SseEncode for () {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
|
|
}
|
|
|
|
impl SseEncode for usize {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
serializer
|
|
.cursor
|
|
.write_u64::<NativeEndian>(self as _)
|
|
.unwrap();
|
|
}
|
|
}
|
|
|
|
#[cfg(not(target_family = "wasm"))]
|
|
#[path = "frb_generated.io.rs"]
|
|
mod io;
|
|
#[cfg(not(target_family = "wasm"))]
|
|
pub use io::*;
|