aljaz/breez-sdk-liquid
1
0
Fork 0
mirror of https://github.com/aljazceru/breez-sdk-liquid.git synced 2025-12-24 01:14:22 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add fetch_onchain_limits service method (#343)

Browse Source 
* Add pay_onchain_limits service method

* Add receive_onchain_limits service method

* Merge pay/receive_onchain_limits

* Update field names

* Split swapper method in get_chain_pair and get_chain_pairs

* Fix test

* Introduce and re-use Limits model

* Add fetch_lightning_limits SDK method

* Fix CI: propagate latest sdk-common changes
This commit is contained in:
ok300
2024-07-03 11:22:29 +02:00
committed by GitHub
parent 639ef0cca5
commit 08b2e5a6e2
26 changed files with 1404 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
cli/Cargo.lock generated
View File

@@ -2670,7 +2670,7 @@ dependencies = [
[[package]]
name = "sdk-common"
version = "0.4.2-rc3"
source = "git+https://github.com/breez/breez-sdk?branch=main#9d44ddd5fcf4a0ee70016bbb80227196b75eb788"
source = "git+https://github.com/breez/breez-sdk?branch=main#8c27e8bf9bd438da411c7bfefd6a7fa10afa269e"
dependencies = [
"aes 0.8.4",
"anyhow",

12
cli/src/commands.rs
View File

@@ -28,6 +28,10 @@ pub(crate) enum Command {
#[arg(short, long)]
delay: Option<u64>,
},
/// Fetch the current limits for Send and Receive payments
FetchLightningLimits,
/// Fetch the current limits for Onchain Send and Receive payments
FetchOnchainLimits,
/// Send lbtc and receive btc onchain through a swap
SendOnchainPayment {
/// Btc onchain address to send to
@@ -179,6 +183,14 @@ pub(crate) async fn handle_command(
result.push_str(&build_qr_text(&invoice));
result
}
Command::FetchLightningLimits => {
let limits = sdk.fetch_lightning_limits().await?;
command_result!(limits)
}
Command::FetchOnchainLimits => {
let limits = sdk.fetch_onchain_limits().await?;
command_result!(limits)
}
Command::SendPayment { bolt11, delay } => {
let prepare_response = sdk
.prepare_send_payment(&PrepareSendRequest { invoice: bolt11 })

2
lib/Cargo.lock generated
View File

@@ -3006,7 +3006,7 @@ dependencies = [
[[package]]
name = "sdk-common"
version = "0.4.2-rc3"
source = "git+https://github.com/breez/breez-sdk?branch=main#9d44ddd5fcf4a0ee70016bbb80227196b75eb788"
source = "git+https://github.com/breez/breez-sdk?branch=main#8c27e8bf9bd438da411c7bfefd6a7fa10afa269e"
dependencies = [
"aes 0.8.4",
"anyhow",

29
lib/bindings/langs/flutter/breez_liquid_sdk/include/breez_liquid_sdk.h
View File

@@ -459,6 +459,17 @@ typedef struct wire_cst_input_type {
union InputTypeKind kind;
} wire_cst_input_type;
typedef struct wire_cst_limits {
uint64_t min_sat;
uint64_t max_sat;
uint64_t max_zero_conf_sat;
} wire_cst_limits;
typedef struct wire_cst_lightning_payment_limits_response {
struct wire_cst_limits send;
struct wire_cst_limits receive;
} wire_cst_lightning_payment_limits_response;
typedef struct wire_cst_LiquidSdkError_Generic {
struct wire_cst_list_prim_u_8_strict *err;
} wire_cst_LiquidSdkError_Generic;
@@ -641,12 +652,17 @@ typedef struct wire_cst_LnUrlWithdrawResult_Ok {
struct wire_cst_ln_url_withdraw_success_data *data;
} wire_cst_LnUrlWithdrawResult_Ok;
typedef struct wire_cst_LnUrlWithdrawResult_Timeout {
struct wire_cst_ln_url_withdraw_success_data *data;
} wire_cst_LnUrlWithdrawResult_Timeout;
typedef struct wire_cst_LnUrlWithdrawResult_ErrorStatus {
struct wire_cst_ln_url_error_data *data;
} wire_cst_LnUrlWithdrawResult_ErrorStatus;
typedef union LnUrlWithdrawResultKind {
struct wire_cst_LnUrlWithdrawResult_Ok Ok;
struct wire_cst_LnUrlWithdrawResult_Timeout Timeout;
struct wire_cst_LnUrlWithdrawResult_ErrorStatus ErrorStatus;
} LnUrlWithdrawResultKind;
@@ -660,6 +676,11 @@ typedef struct wire_cst_log_entry {
struct wire_cst_list_prim_u_8_strict *level;
} wire_cst_log_entry;
typedef struct wire_cst_onchain_payment_limits_response {
struct wire_cst_limits send;
struct wire_cst_limits receive;
} wire_cst_onchain_payment_limits_response;
typedef struct wire_cst_PaymentError_Generic {
struct wire_cst_list_prim_u_8_strict *err;
} wire_cst_PaymentError_Generic;
@@ -743,6 +764,12 @@ WireSyncRust2DartDco frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk
void frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates(int64_t port_,
uintptr_t that);
void frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(int64_t port_,
uintptr_t that);
void frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(int64_t port_,
uintptr_t that);
void frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info(int64_t port_,
uintptr_t that);
@@ -980,6 +1007,8 @@ static int64_t dummy_method_to_enforce_bundling(void) {
dummy_var ^= ((int64_t) (void*) frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_disconnect);
dummy_var ^= ((int64_t) (void*) frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache);
dummy_var ^= ((int64_t) (void*) frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates);
dummy_var ^= ((int64_t) (void*) frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits);
dummy_var ^= ((int64_t) (void*) frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits);
dummy_var ^= ((int64_t) (void*) frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info);
dummy_var ^= ((int64_t) (void*) frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies);
dummy_var ^= ((int64_t) (void*) frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_payments);

23
lib/bindings/src/breez_liquid_sdk.udl
View File

@@ -157,6 +157,7 @@ interface LnUrlWithdrawError {
[Enum]
interface LnUrlWithdrawResult {
Ok(LnUrlWithdrawSuccessData data);
Timeout(LnUrlWithdrawSuccessData data);
ErrorStatus(LnUrlErrorData data);
};
@@ -335,6 +336,22 @@ dictionary ReceivePaymentResponse {
string invoice;
};
dictionary Limits {
u64 min_sat;
u64 max_sat;
u64 max_zero_conf_sat;
};
dictionary LightningPaymentLimitsResponse {
Limits send;
Limits receive;
};
dictionary OnchainPaymentLimitsResponse {
Limits send;
Limits receive;
};
dictionary PreparePayOnchainRequest {
u64 receiver_amount_sat;
};
@@ -490,6 +507,12 @@ interface BindingLiquidSdk {
[Throws=PaymentError]
ReceivePaymentResponse receive_payment(PrepareReceiveResponse req);
[Throws=PaymentError]
LightningPaymentLimitsResponse fetch_lightning_limits();
[Throws=PaymentError]
OnchainPaymentLimitsResponse fetch_onchain_limits();
[Throws=PaymentError]
PreparePayOnchainResponse prepare_pay_onchain(PreparePayOnchainRequest req);

8
lib/bindings/src/lib.rs
View File

@@ -122,6 +122,14 @@ impl BindingLiquidSdk {
rt().block_on(self.sdk.receive_payment(&req))
}
pub fn fetch_lightning_limits(&self) -> Result<LightningPaymentLimitsResponse, PaymentError> {
rt().block_on(self.sdk.fetch_lightning_limits())
}
pub fn fetch_onchain_limits(&self) -> Result<OnchainPaymentLimitsResponse, PaymentError> {
rt().block_on(self.sdk.fetch_onchain_limits())
}
pub fn prepare_pay_onchain(
&self,
req: PreparePayOnchainRequest,

14
lib/core/src/bindings.rs
View File

@@ -126,6 +126,16 @@ impl BindingLiquidSdk {
self.sdk.receive_payment(&req).await
}
pub async fn fetch_lightning_limits(
&self,
) -> Result<LightningPaymentLimitsResponse, PaymentError> {
self.sdk.fetch_lightning_limits().await
}
pub async fn fetch_onchain_limits(&self) -> Result<OnchainPaymentLimitsResponse, PaymentError> {
self.sdk.fetch_onchain_limits().await
}
pub async fn prepare_pay_onchain(
&self,
req: PreparePayOnchainRequest,
@@ -605,6 +615,7 @@ pub mod duplicates {
#[derive(Clone, Serialize)]
pub enum LnUrlWithdrawResult {
Ok { data: LnUrlWithdrawSuccessData },
Timeout { data: LnUrlWithdrawSuccessData },
ErrorStatus { data: LnUrlErrorData },
}
impl From<sdk_common::prelude::LnUrlWithdrawResult> for LnUrlWithdrawResult {
@@ -613,6 +624,9 @@ pub mod duplicates {
sdk_common::prelude::LnUrlWithdrawResult::Ok { data } => {
Self::Ok { data: data.into() }
}
sdk_common::prelude::LnUrlWithdrawResult::Timeout { data } => {
Self::Timeout { data: data.into() }
}
sdk_common::prelude::LnUrlWithdrawResult::ErrorStatus { data } => {
Self::ErrorStatus { data }
}

119
lib/core/src/frb_generated.io.rs
View File

@@ -520,6 +520,27 @@ impl CstDecode<crate::bindings::InputType> for wire_cst_input_type {
}
}
}
impl CstDecode<crate::model::LightningPaymentLimitsResponse>
for wire_cst_lightning_payment_limits_response
{
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> crate::model::LightningPaymentLimitsResponse {
crate::model::LightningPaymentLimitsResponse {
send: self.send.cst_decode(),
receive: self.receive.cst_decode(),
}
}
}
impl CstDecode<crate::model::Limits> for wire_cst_limits {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> crate::model::Limits {
crate::model::Limits {
min_sat: self.min_sat.cst_decode(),
max_sat: self.max_sat.cst_decode(),
max_zero_conf_sat: self.max_zero_conf_sat.cst_decode(),
}
}
}
impl CstDecode<crate::error::LiquidSdkError> for wire_cst_liquid_sdk_error {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> crate::error::LiquidSdkError {
@@ -984,6 +1005,12 @@ impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawResult>
}
}
1 => {
let ans = unsafe { self.kind.Timeout };
crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
data: ans.data.cst_decode(),
}
}
2 => {
let ans = unsafe { self.kind.ErrorStatus };
crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
data: ans.data.cst_decode(),
@@ -1039,6 +1066,17 @@ impl CstDecode<crate::bindings::MessageSuccessActionData> for wire_cst_message_s
}
}
}
impl CstDecode<crate::model::OnchainPaymentLimitsResponse>
for wire_cst_onchain_payment_limits_response
{
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> crate::model::OnchainPaymentLimitsResponse {
crate::model::OnchainPaymentLimitsResponse {
send: self.send.cst_decode(),
receive: self.receive.cst_decode(),
}
}
}
impl CstDecode<crate::model::PayOnchainRequest> for wire_cst_pay_onchain_request {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> crate::model::PayOnchainRequest {
@@ -1515,6 +1553,33 @@ impl Default for wire_cst_input_type {
Self::new_with_null_ptr()
}
}
impl NewWithNullPtr for wire_cst_lightning_payment_limits_response {
fn new_with_null_ptr() -> Self {
Self {
send: Default::default(),
receive: Default::default(),
}
}
}
impl Default for wire_cst_lightning_payment_limits_response {
fn default() -> Self {
Self::new_with_null_ptr()
}
}
impl NewWithNullPtr for wire_cst_limits {
fn new_with_null_ptr() -> Self {
Self {
min_sat: Default::default(),
max_sat: Default::default(),
max_zero_conf_sat: Default::default(),
}
}
}
impl Default for wire_cst_limits {
fn default() -> Self {
Self::new_with_null_ptr()
}
}
impl NewWithNullPtr for wire_cst_liquid_sdk_error {
fn new_with_null_ptr() -> Self {
Self {
@@ -1824,6 +1889,19 @@ impl Default for wire_cst_message_success_action_data {
Self::new_with_null_ptr()
}
}
impl NewWithNullPtr for wire_cst_onchain_payment_limits_response {
fn new_with_null_ptr() -> Self {
Self {
send: Default::default(),
receive: Default::default(),
}
}
}
impl Default for wire_cst_onchain_payment_limits_response {
fn default() -> Self {
Self::new_with_null_ptr()
}
}
impl NewWithNullPtr for wire_cst_pay_onchain_request {
fn new_with_null_ptr() -> Self {
Self {
@@ -2215,6 +2293,22 @@ pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fe
wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(port_, that)
}
#[no_mangle]
pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
port_: i64,
that: usize,
) {
wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(port_, that)
}
#[no_mangle]
pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
port_: i64,
that: usize,
) {
wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(port_, that)
}
#[no_mangle]
pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info(
port_: i64,
@@ -2993,6 +3087,19 @@ pub struct wire_cst_InputType_LnUrlError {
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct wire_cst_lightning_payment_limits_response {
send: wire_cst_limits,
receive: wire_cst_limits,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct wire_cst_limits {
min_sat: u64,
max_sat: u64,
max_zero_conf_sat: u64,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct wire_cst_liquid_sdk_error {
tag: i32,
kind: LiquidSdkErrorKind,
@@ -3402,6 +3509,7 @@ pub struct wire_cst_ln_url_withdraw_result {
#[derive(Clone, Copy)]
pub union LnUrlWithdrawResultKind {
Ok: wire_cst_LnUrlWithdrawResult_Ok,
Timeout: wire_cst_LnUrlWithdrawResult_Timeout,
ErrorStatus: wire_cst_LnUrlWithdrawResult_ErrorStatus,
nil__: (),
}
@@ -3412,6 +3520,11 @@ pub struct wire_cst_LnUrlWithdrawResult_Ok {
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct wire_cst_LnUrlWithdrawResult_Timeout {
data: *mut wire_cst_ln_url_withdraw_success_data,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct wire_cst_LnUrlWithdrawResult_ErrorStatus {
data: *mut wire_cst_ln_url_error_data,
}
@@ -3446,6 +3559,12 @@ pub struct wire_cst_message_success_action_data {
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct wire_cst_onchain_payment_limits_response {
send: wire_cst_limits,
receive: wire_cst_limits,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct wire_cst_pay_onchain_request {
address: *mut wire_cst_list_prim_u_8_strict,
prepare_res: wire_cst_prepare_pay_onchain_response,

238
lib/core/src/frb_generated.rs
View File

@@ -39,7 +39,7 @@ flutter_rust_bridge::frb_generated_boilerplate!(
default_rust_auto_opaque = RustAutoOpaqueNom,
);
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.0.0";
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 1515195984;
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -1318462354;
// Section: executor
@@ -259,6 +259,98 @@ fn wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(
},
)
}
fn wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_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_fetch_lightning_limits",
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::<_, _, crate::error::PaymentError>(
(move || async move {
let mut api_that_guard = 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_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::bindings::BindingLiquidSdk::fetch_lightning_limits(
&*api_that_guard,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_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_fetch_onchain_limits",
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::<_, _, crate::error::PaymentError>(
(move || async move {
let mut api_that_guard = 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_guard =
Some(api_that.lockable_decode_async_ref().await)
}
_ => unreachable!(),
}
}
let api_that_guard = api_that_guard.unwrap();
let output_ok = crate::bindings::BindingLiquidSdk::fetch_onchain_limits(
&*api_that_guard,
)
.await?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
fn wire__crate__bindings__BindingLiquidSdk_get_info_impl(
port_: flutter_rust_bridge::for_generated::MessagePort,
that: impl CstDecode<
@@ -1921,6 +2013,32 @@ impl SseDecode for crate::bindings::InputType {
}
}
impl SseDecode for crate::model::LightningPaymentLimitsResponse {
// 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_send = <crate::model::Limits>::sse_decode(deserializer);
let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
return crate::model::LightningPaymentLimitsResponse {
send: var_send,
receive: var_receive,
};
}
}
impl SseDecode for crate::model::Limits {
// 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_minSat = <u64>::sse_decode(deserializer);
let mut var_maxSat = <u64>::sse_decode(deserializer);
let mut var_maxZeroConfSat = <u64>::sse_decode(deserializer);
return crate::model::Limits {
min_sat: var_minSat,
max_sat: var_maxSat,
max_zero_conf_sat: var_maxZeroConfSat,
};
}
}
impl SseDecode for crate::model::LiquidNetwork {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
@@ -2466,6 +2584,15 @@ impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawResult {
return crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data: var_data };
}
1 => {
let mut var_data =
<crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
deserializer,
);
return crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
data: var_data,
};
}
2 => {
let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
return crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
data: var_data,
@@ -2550,6 +2677,18 @@ impl SseDecode for crate::bindings::Network {
}
}
impl SseDecode for crate::model::OnchainPaymentLimitsResponse {
// 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_send = <crate::model::Limits>::sse_decode(deserializer);
let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
return crate::model::OnchainPaymentLimitsResponse {
send: var_send,
receive: var_receive,
};
}
}
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 {
@@ -3399,6 +3538,44 @@ impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::InputType>>
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::model::LightningPaymentLimitsResponse {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.send.into_into_dart().into_dart(),
self.receive.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::model::LightningPaymentLimitsResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::model::LightningPaymentLimitsResponse>
for crate::model::LightningPaymentLimitsResponse
{
fn into_into_dart(self) -> crate::model::LightningPaymentLimitsResponse {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::model::Limits {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.min_sat.into_into_dart().into_dart(),
self.max_sat.into_into_dart().into_dart(),
self.max_zero_conf_sat.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Limits {}
impl flutter_rust_bridge::IntoIntoDart<crate::model::Limits> for crate::model::Limits {
fn into_into_dart(self) -> crate::model::Limits {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::model::LiquidNetwork {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
match self {
@@ -3875,9 +4052,12 @@ impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdra
crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
[0.into_dart(), data.into_into_dart().into_dart()].into_dart()
}
crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
[1.into_dart(), data.into_into_dart().into_dart()].into_dart()
}
crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
[2.into_dart(), data.into_into_dart().into_dart()].into_dart()
}
_ => {
unimplemented!("");
}
@@ -4012,6 +4192,27 @@ impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Network>>
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::model::OnchainPaymentLimitsResponse {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.send.into_into_dart().into_dart(),
self.receive.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::model::OnchainPaymentLimitsResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::model::OnchainPaymentLimitsResponse>
for crate::model::OnchainPaymentLimitsResponse
{
fn into_into_dart(self) -> crate::model::OnchainPaymentLimitsResponse {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::model::PayOnchainRequest {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
@@ -4833,6 +5034,23 @@ impl SseEncode for crate::bindings::InputType {
}
}
impl SseEncode for crate::model::LightningPaymentLimitsResponse {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<crate::model::Limits>::sse_encode(self.send, serializer);
<crate::model::Limits>::sse_encode(self.receive, serializer);
}
}
impl SseEncode for crate::model::Limits {
// 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.min_sat, serializer);
<u64>::sse_encode(self.max_sat, serializer);
<u64>::sse_encode(self.max_zero_conf_sat, serializer);
}
}
impl SseEncode for crate::model::LiquidNetwork {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
@@ -5268,8 +5486,14 @@ impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawResult {
data, serializer,
);
}
crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
<i32>::sse_encode(1, serializer);
<crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
data, serializer,
);
}
crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
<i32>::sse_encode(2, serializer);
<crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
}
_ => {
@@ -5336,6 +5560,14 @@ impl SseEncode for crate::bindings::Network {
}
}
impl SseEncode for crate::model::OnchainPaymentLimitsResponse {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<crate::model::Limits>::sse_encode(self.send, serializer);
<crate::model::Limits>::sse_encode(self.receive, 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) {

23
lib/core/src/model.rs
View File

@@ -183,6 +183,29 @@ pub struct ReceivePaymentResponse {
pub invoice: String,
}
#[derive(Debug, Serialize)]
pub struct Limits {
pub min_sat: u64,
pub max_sat: u64,
pub max_zero_conf_sat: u64,
}
#[derive(Debug, Serialize)]
pub struct LightningPaymentLimitsResponse {
/// Amount limits for a Send Payment to be valid
pub send: Limits,
/// Amount limits for a Receive Payment to be valid
pub receive: Limits,
}
#[derive(Debug, Serialize)]
pub struct OnchainPaymentLimitsResponse {
/// Amount limits for a Send Onchain Payment to be valid
pub send: Limits,
/// Amount limits for a Receive Onchain Payment to be valid
pub receive: Limits,
}
#[derive(Debug, Serialize, Clone)]
pub struct PrepareSendRequest {
pub invoice: String,

60
lib/core/src/sdk.rs
View File

@@ -589,7 +589,7 @@ impl LiquidSdk {
) -> Result<ChainPair, PaymentError> {
let pair = self
.swapper
.get_chain_pairs(direction)?
.get_chain_pair(direction)?
.ok_or(PaymentError::PairsNotFound)?;
pair.limits.within(amount_sat)?;
@@ -875,6 +875,64 @@ impl LiquidSdk {
.map(|payment| SendPaymentResponse { payment })
}
/// Fetch the current limits for Send and Receive swaps
pub async fn fetch_lightning_limits(
&self,
) -> Result<LightningPaymentLimitsResponse, PaymentError> {
self.ensure_is_started().await?;
let submarine_pair = self
.swapper
.get_submarine_pairs()?
.ok_or(PaymentError::PairsNotFound)?;
let send_limits = submarine_pair.limits;
let reverse_pair = self
.swapper
.get_reverse_swap_pairs()?
.ok_or(PaymentError::PairsNotFound)?;
let receive_limits = reverse_pair.limits;
Ok(LightningPaymentLimitsResponse {
send: Limits {
min_sat: send_limits.minimal,
max_sat: send_limits.maximal,
max_zero_conf_sat: send_limits.maximal_zero_conf,
},
receive: Limits {
min_sat: receive_limits.minimal,
max_sat: receive_limits.maximal,
max_zero_conf_sat: self.config.zero_conf_max_amount_sat(),
},
})
}
/// Fetch the current limits for Onchain Send and Receive swaps
pub async fn fetch_onchain_limits(&self) -> Result<OnchainPaymentLimitsResponse, PaymentError> {
self.ensure_is_started().await?;
let (pair_outgoing, pair_incoming) = self.swapper.get_chain_pairs()?;
let send_limits = pair_outgoing
.ok_or(PaymentError::PairsNotFound)
.map(|pair| pair.limits)?;
let receive_limits = pair_incoming
.ok_or(PaymentError::PairsNotFound)
.map(|pair| pair.limits)?;
Ok(OnchainPaymentLimitsResponse {
send: Limits {
min_sat: send_limits.minimal,
max_sat: send_limits.maximal,
max_zero_conf_sat: send_limits.maximal_zero_conf,
},
receive: Limits {
min_sat: receive_limits.minimal,
max_sat: receive_limits.maximal,
max_zero_conf_sat: receive_limits.maximal_zero_conf,
},
})
}
pub async fn prepare_pay_onchain(
&self,
req: &PreparePayOnchainRequest,

17
lib/core/src/swapper/mod.rs
View File

@@ -59,8 +59,11 @@ pub trait Swapper: Send + Sync {
req: CreateSubmarineRequest,
) -> Result<CreateSubmarineResponse, PaymentError>;
/// Get a chain pair information
fn get_chain_pairs(&self, direction: Direction) -> Result<Option<ChainPair>, PaymentError>;
/// Get the current rate, limits and fees for a given swap direction
fn get_chain_pair(&self, direction: Direction) -> Result<Option<ChainPair>, PaymentError>;
/// Get the current rate, limits and fees for both swap directions
fn get_chain_pairs(&self) -> Result<(Option<ChainPair>, Option<ChainPair>), PaymentError>;
/// Get a submarine pair information
fn get_submarine_pairs(&self) -> Result<Option<SubmarinePair>, PaymentError>;
@@ -501,8 +504,7 @@ impl Swapper for BoltzSwapper {
Ok(self.client.post_swap_req(&modified_req)?)
}
/// Get a chain pair information
fn get_chain_pairs(&self, direction: Direction) -> Result<Option<ChainPair>, PaymentError> {
fn get_chain_pair(&self, direction: Direction) -> Result<Option<ChainPair>, PaymentError> {
let pairs = self.client.get_chain_pairs()?;
let pair = match direction {
Direction::Incoming => pairs.get_btc_to_lbtc_pair(),
@@ -511,6 +513,13 @@ impl Swapper for BoltzSwapper {
Ok(pair)
}
fn get_chain_pairs(&self) -> Result<(Option<ChainPair>, Option<ChainPair>), PaymentError> {
let pairs = self.client.get_chain_pairs()?;
let pair_outgoing = pairs.get_lbtc_to_btc_pair();
let pair_incoming = pairs.get_btc_to_lbtc_pair();
Ok((pair_outgoing, pair_incoming))
}
/// Get a submarine pair information
fn get_submarine_pairs(&self) -> Result<Option<SubmarinePair>, PaymentError> {
Ok(self.client.get_submarine_pairs()?.get_lbtc_to_btc_pair())

28
lib/core/src/test_utils/swapper.rs
View File

@@ -99,7 +99,10 @@ impl Swapper for MockSwapper {
})
}
fn get_chain_pairs(&self, _direction: Direction) -> Result<Option<ChainPair>, PaymentError> {
fn get_chain_pair(
&self,
_direction: Direction,
) -> anyhow::Result<Option<ChainPair>, PaymentError> {
Ok(Some(ChainPair {
hash: generate_random_string(10),
rate: 0.0,
@@ -121,6 +124,29 @@ impl Swapper for MockSwapper {
}))
}
fn get_chain_pairs(&self) -> Result<(Option<ChainPair>, Option<ChainPair>), PaymentError> {
let test_pair = Some(ChainPair {
hash: generate_random_string(10),
rate: 0.0,
limits: PairLimits {
maximal: u64::MAX,
minimal: 0,
maximal_zero_conf: 100_000,
},
fees: ChainFees {
percentage: 0.1,
miner_fees: ChainMinerFees {
server: 100,
user: PairMinerFees {
lockup: 100,
claim: 100,
},
},
},
});
Ok((test_pair.clone(), test_pair))
}
fn get_submarine_pairs(&self) -> Result<Option<SubmarinePair>, PaymentError> {
Ok(Some(SubmarinePair {
hash: generate_random_string(10),

4
packages/dart/lib/src/bindings.dart
View File

@@ -41,6 +41,10 @@ abstract class BindingLiquidSdk implements RustOpaqueInterface {
Future<List<Rate>> fetchFiatRates();
Future<LightningPaymentLimitsResponse> fetchLightningLimits();
Future<OnchainPaymentLimitsResponse> fetchOnchainLimits();
Future<GetInfoResponse> getInfo();
Future<List<FiatCurrency>> listFiatCurrencies();

3
packages/dart/lib/src/bindings/duplicates.dart
View File

@@ -156,6 +156,9 @@ sealed class LnUrlWithdrawResult with _$LnUrlWithdrawResult {
const factory LnUrlWithdrawResult.ok({
required LnUrlWithdrawSuccessData data,
}) = LnUrlWithdrawResult_Ok;
const factory LnUrlWithdrawResult.timeout({
required LnUrlWithdrawSuccessData data,
}) = LnUrlWithdrawResult_Timeout;
const factory LnUrlWithdrawResult.errorStatus({
required LnUrlErrorData data,
}) = LnUrlWithdrawResult_ErrorStatus;

74
packages/dart/lib/src/bindings/duplicates.freezed.dart
View File

@@ -1882,6 +1882,80 @@ abstract class LnUrlWithdrawResult_Ok extends LnUrlWithdrawResult {
throw _privateConstructorUsedError;
}
/// @nodoc
abstract class _$$LnUrlWithdrawResult_TimeoutImplCopyWith<$Res> {
factory _$$LnUrlWithdrawResult_TimeoutImplCopyWith(
_$LnUrlWithdrawResult_TimeoutImpl value, $Res Function(_$LnUrlWithdrawResult_TimeoutImpl) then) =
__$$LnUrlWithdrawResult_TimeoutImplCopyWithImpl<$Res>;
@useResult
$Res call({LnUrlWithdrawSuccessData data});
}
/// @nodoc
class __$$LnUrlWithdrawResult_TimeoutImplCopyWithImpl<$Res>
extends _$LnUrlWithdrawResultCopyWithImpl<$Res, _$LnUrlWithdrawResult_TimeoutImpl>
implements _$$LnUrlWithdrawResult_TimeoutImplCopyWith<$Res> {
__$$LnUrlWithdrawResult_TimeoutImplCopyWithImpl(
_$LnUrlWithdrawResult_TimeoutImpl _value, $Res Function(_$LnUrlWithdrawResult_TimeoutImpl) _then)
: super(_value, _then);
@pragma('vm:prefer-inline')
@override
$Res call({
Object? data = null,
}) {
return _then(_$LnUrlWithdrawResult_TimeoutImpl(
data: null == data
? _value.data
: data // ignore: cast_nullable_to_non_nullable
as LnUrlWithdrawSuccessData,
));
}
}
/// @nodoc
class _$LnUrlWithdrawResult_TimeoutImpl extends LnUrlWithdrawResult_Timeout {
const _$LnUrlWithdrawResult_TimeoutImpl({required this.data}) : super._();
@override
final LnUrlWithdrawSuccessData data;
@override
String toString() {
return 'LnUrlWithdrawResult.timeout(data: $data)';
}
@override
bool operator ==(Object other) {
return identical(this, other) ||
(other.runtimeType == runtimeType &&
other is _$LnUrlWithdrawResult_TimeoutImpl &&
(identical(other.data, data) || other.data == data));
}
@override
int get hashCode => Object.hash(runtimeType, data);
@JsonKey(ignore: true)
@override
@pragma('vm:prefer-inline')
_$$LnUrlWithdrawResult_TimeoutImplCopyWith<_$LnUrlWithdrawResult_TimeoutImpl> get copyWith =>
__$$LnUrlWithdrawResult_TimeoutImplCopyWithImpl<_$LnUrlWithdrawResult_TimeoutImpl>(this, _$identity);
}
abstract class LnUrlWithdrawResult_Timeout extends LnUrlWithdrawResult {
const factory LnUrlWithdrawResult_Timeout({required final LnUrlWithdrawSuccessData data}) =
_$LnUrlWithdrawResult_TimeoutImpl;
const LnUrlWithdrawResult_Timeout._() : super._();
@override
LnUrlWithdrawSuccessData get data;
@JsonKey(ignore: true)
_$$LnUrlWithdrawResult_TimeoutImplCopyWith<_$LnUrlWithdrawResult_TimeoutImpl> get copyWith =>
throw _privateConstructorUsedError;
}
/// @nodoc
abstract class _$$LnUrlWithdrawResult_ErrorStatusImplCopyWith<$Res> {
factory _$$LnUrlWithdrawResult_ErrorStatusImplCopyWith(_$LnUrlWithdrawResult_ErrorStatusImpl value,

163
packages/dart/lib/src/frb_generated.dart
View File

@@ -55,7 +55,7 @@ class RustLib extends BaseEntrypoint<RustLibApi, RustLibApiImpl, RustLibWire> {
String get codegenVersion => '2.0.0';
@override
int get rustContentHash => 1515195984;
int get rustContentHash => -1318462354;
static const kDefaultExternalLibraryLoaderConfig = ExternalLibraryLoaderConfig(
stem: 'breez_liquid_sdk',
@@ -75,6 +75,12 @@ abstract class RustLibApi extends BaseApi {
Future<List<Rate>> crateBindingsBindingLiquidSdkFetchFiatRates({required BindingLiquidSdk that});
Future<LightningPaymentLimitsResponse> crateBindingsBindingLiquidSdkFetchLightningLimits(
{required BindingLiquidSdk that});
Future<OnchainPaymentLimitsResponse> crateBindingsBindingLiquidSdkFetchOnchainLimits(
{required BindingLiquidSdk that});
Future<GetInfoResponse> crateBindingsBindingLiquidSdkGetInfo({required BindingLiquidSdk that});
Future<List<FiatCurrency>> crateBindingsBindingLiquidSdkListFiatCurrencies(
@@ -281,6 +287,56 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
argNames: ["that"],
);
@override
Future<LightningPaymentLimitsResponse> crateBindingsBindingLiquidSdkFetchLightningLimits(
{required BindingLiquidSdk that}) {
return handler.executeNormal(NormalTask(
callFfi: (port_) {
var arg0 =
cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
that);
return wire.wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(port_, arg0);
},
codec: DcoCodec(
decodeSuccessData: dco_decode_lightning_payment_limits_response,
decodeErrorData: dco_decode_payment_error,
),
constMeta: kCrateBindingsBindingLiquidSdkFetchLightningLimitsConstMeta,
argValues: [that],
apiImpl: this,
));
}
TaskConstMeta get kCrateBindingsBindingLiquidSdkFetchLightningLimitsConstMeta => const TaskConstMeta(
debugName: "BindingLiquidSdk_fetch_lightning_limits",
argNames: ["that"],
);
@override
Future<OnchainPaymentLimitsResponse> crateBindingsBindingLiquidSdkFetchOnchainLimits(
{required BindingLiquidSdk that}) {
return handler.executeNormal(NormalTask(
callFfi: (port_) {
var arg0 =
cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
that);
return wire.wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(port_, arg0);
},
codec: DcoCodec(
decodeSuccessData: dco_decode_onchain_payment_limits_response,
decodeErrorData: dco_decode_payment_error,
),
constMeta: kCrateBindingsBindingLiquidSdkFetchOnchainLimitsConstMeta,
argValues: [that],
apiImpl: this,
));
}
TaskConstMeta get kCrateBindingsBindingLiquidSdkFetchOnchainLimitsConstMeta => const TaskConstMeta(
debugName: "BindingLiquidSdk_fetch_onchain_limits",
argNames: ["that"],
);
@override
Future<GetInfoResponse> crateBindingsBindingLiquidSdkGetInfo({required BindingLiquidSdk that}) {
return handler.executeNormal(NormalTask(
@@ -1390,6 +1446,29 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
}
}
@protected
LightningPaymentLimitsResponse dco_decode_lightning_payment_limits_response(dynamic raw) {
// Codec=Dco (DartCObject based), see doc to use other codecs
final arr = raw as List<dynamic>;
if (arr.length != 2) throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
return LightningPaymentLimitsResponse(
send: dco_decode_limits(arr[0]),
receive: dco_decode_limits(arr[1]),
);
}
@protected
Limits dco_decode_limits(dynamic raw) {
// Codec=Dco (DartCObject based), see doc to use other codecs
final arr = raw as List<dynamic>;
if (arr.length != 3) throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
return Limits(
minSat: dco_decode_u_64(arr[0]),
maxSat: dco_decode_u_64(arr[1]),
maxZeroConfSat: dco_decode_u_64(arr[2]),
);
}
@protected
LiquidNetwork dco_decode_liquid_network(dynamic raw) {
// Codec=Dco (DartCObject based), see doc to use other codecs
@@ -1783,6 +1862,10 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
data: dco_decode_box_autoadd_ln_url_withdraw_success_data(raw[1]),
);
case 1:
return LnUrlWithdrawResult_Timeout(
data: dco_decode_box_autoadd_ln_url_withdraw_success_data(raw[1]),
);
case 2:
return LnUrlWithdrawResult_ErrorStatus(
data: dco_decode_box_autoadd_ln_url_error_data(raw[1]),
);
@@ -1851,6 +1934,17 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
return Network.values[raw as int];
}
@protected
OnchainPaymentLimitsResponse dco_decode_onchain_payment_limits_response(dynamic raw) {
// Codec=Dco (DartCObject based), see doc to use other codecs
final arr = raw as List<dynamic>;
if (arr.length != 2) throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
return OnchainPaymentLimitsResponse(
send: dco_decode_limits(arr[0]),
receive: dco_decode_limits(arr[1]),
);
}
@protected
String? dco_decode_opt_String(dynamic raw) {
// Codec=Dco (DartCObject based), see doc to use other codecs
@@ -2748,6 +2842,23 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
}
}
@protected
LightningPaymentLimitsResponse sse_decode_lightning_payment_limits_response(SseDeserializer deserializer) {
// Codec=Sse (Serialization based), see doc to use other codecs
var var_send = sse_decode_limits(deserializer);
var var_receive = sse_decode_limits(deserializer);
return LightningPaymentLimitsResponse(send: var_send, receive: var_receive);
}
@protected
Limits sse_decode_limits(SseDeserializer deserializer) {
// Codec=Sse (Serialization based), see doc to use other codecs
var var_minSat = sse_decode_u_64(deserializer);
var var_maxSat = sse_decode_u_64(deserializer);
var var_maxZeroConfSat = sse_decode_u_64(deserializer);
return Limits(minSat: var_minSat, maxSat: var_maxSat, maxZeroConfSat: var_maxZeroConfSat);
}
@protected
LiquidNetwork sse_decode_liquid_network(SseDeserializer deserializer) {
// Codec=Sse (Serialization based), see doc to use other codecs
@@ -3174,6 +3285,9 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
var var_data = sse_decode_box_autoadd_ln_url_withdraw_success_data(deserializer);
return LnUrlWithdrawResult_Ok(data: var_data);
case 1:
var var_data = sse_decode_box_autoadd_ln_url_withdraw_success_data(deserializer);
return LnUrlWithdrawResult_Timeout(data: var_data);
case 2:
var var_data = sse_decode_box_autoadd_ln_url_error_data(deserializer);
return LnUrlWithdrawResult_ErrorStatus(data: var_data);
default:
@@ -3227,6 +3341,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
return Network.values[inner];
}
@protected
OnchainPaymentLimitsResponse sse_decode_onchain_payment_limits_response(SseDeserializer deserializer) {
// Codec=Sse (Serialization based), see doc to use other codecs
var var_send = sse_decode_limits(deserializer);
var var_receive = sse_decode_limits(deserializer);
return OnchainPaymentLimitsResponse(send: var_send, receive: var_receive);
}
@protected
String? sse_decode_opt_String(SseDeserializer deserializer) {
// Codec=Sse (Serialization based), see doc to use other codecs
@@ -4170,6 +4292,22 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
}
}
@protected
void sse_encode_lightning_payment_limits_response(
LightningPaymentLimitsResponse self, SseSerializer serializer) {
// Codec=Sse (Serialization based), see doc to use other codecs
sse_encode_limits(self.send, serializer);
sse_encode_limits(self.receive, serializer);
}
@protected
void sse_encode_limits(Limits self, SseSerializer serializer) {
// Codec=Sse (Serialization based), see doc to use other codecs
sse_encode_u_64(self.minSat, serializer);
sse_encode_u_64(self.maxSat, serializer);
sse_encode_u_64(self.maxZeroConfSat, serializer);
}
@protected
void sse_encode_liquid_network(LiquidNetwork self, SseSerializer serializer) {
// Codec=Sse (Serialization based), see doc to use other codecs
@@ -4518,8 +4656,11 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
case LnUrlWithdrawResult_Ok(data: final data):
sse_encode_i_32(0, serializer);
sse_encode_box_autoadd_ln_url_withdraw_success_data(data, serializer);
case LnUrlWithdrawResult_ErrorStatus(data: final data):
case LnUrlWithdrawResult_Timeout(data: final data):
sse_encode_i_32(1, serializer);
sse_encode_box_autoadd_ln_url_withdraw_success_data(data, serializer);
case LnUrlWithdrawResult_ErrorStatus(data: final data):
sse_encode_i_32(2, serializer);
sse_encode_box_autoadd_ln_url_error_data(data, serializer);
default:
throw UnimplementedError('');
@@ -4566,6 +4707,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
sse_encode_i_32(self.index, serializer);
}
@protected
void sse_encode_onchain_payment_limits_response(
OnchainPaymentLimitsResponse self, SseSerializer serializer) {
// Codec=Sse (Serialization based), see doc to use other codecs
sse_encode_limits(self.send, serializer);
sse_encode_limits(self.receive, serializer);
}
@protected
void sse_encode_opt_String(String? self, SseSerializer serializer) {
// Codec=Sse (Serialization based), see doc to use other codecs
@@ -4964,6 +5113,16 @@ class BindingLiquidSdkImpl extends RustOpaque implements BindingLiquidSdk {
that: this,
);
Future<LightningPaymentLimitsResponse> fetchLightningLimits() =>
RustLib.instance.api.crateBindingsBindingLiquidSdkFetchLightningLimits(
that: this,
);
Future<OnchainPaymentLimitsResponse> fetchOnchainLimits() =>
RustLib.instance.api.crateBindingsBindingLiquidSdkFetchOnchainLimits(
that: this,
);
Future<GetInfoResponse> getInfo() => RustLib.instance.api.crateBindingsBindingLiquidSdkGetInfo(
that: this,
);

120
packages/dart/lib/src/frb_generated.io.dart
View File

@@ -203,6 +203,12 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl<RustLibWire> {
@protected
InputType dco_decode_input_type(dynamic raw);
@protected
LightningPaymentLimitsResponse dco_decode_lightning_payment_limits_response(dynamic raw);
@protected
Limits dco_decode_limits(dynamic raw);
@protected
LiquidNetwork dco_decode_liquid_network(dynamic raw);
@@ -302,6 +308,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl<RustLibWire> {
@protected
Network dco_decode_network(dynamic raw);
@protected
OnchainPaymentLimitsResponse dco_decode_onchain_payment_limits_response(dynamic raw);
@protected
String? dco_decode_opt_String(dynamic raw);
@@ -605,6 +614,12 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl<RustLibWire> {
@protected
InputType sse_decode_input_type(SseDeserializer deserializer);
@protected
LightningPaymentLimitsResponse sse_decode_lightning_payment_limits_response(SseDeserializer deserializer);
@protected
Limits sse_decode_limits(SseDeserializer deserializer);
@protected
LiquidNetwork sse_decode_liquid_network(SseDeserializer deserializer);
@@ -704,6 +719,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl<RustLibWire> {
@protected
Network sse_decode_network(SseDeserializer deserializer);
@protected
OnchainPaymentLimitsResponse sse_decode_onchain_payment_limits_response(SseDeserializer deserializer);
@protected
String? sse_decode_opt_String(SseDeserializer deserializer);
@@ -1635,6 +1653,20 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl<RustLibWire> {
}
}
@protected
void cst_api_fill_to_wire_lightning_payment_limits_response(
LightningPaymentLimitsResponse apiObj, wire_cst_lightning_payment_limits_response wireObj) {
cst_api_fill_to_wire_limits(apiObj.send, wireObj.send);
cst_api_fill_to_wire_limits(apiObj.receive, wireObj.receive);
}
@protected
void cst_api_fill_to_wire_limits(Limits apiObj, wire_cst_limits wireObj) {
wireObj.min_sat = cst_encode_u_64(apiObj.minSat);
wireObj.max_sat = cst_encode_u_64(apiObj.maxSat);
wireObj.max_zero_conf_sat = cst_encode_u_64(apiObj.maxZeroConfSat);
}
@protected
void cst_api_fill_to_wire_liquid_sdk_error(LiquidSdkError apiObj, wire_cst_liquid_sdk_error wireObj) {
if (apiObj is LiquidSdkError_AlreadyStarted) {
@@ -1970,9 +2002,15 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl<RustLibWire> {
wireObj.kind.Ok.data = pre_data;
return;
}
if (apiObj is LnUrlWithdrawResult_Timeout) {
var pre_data = cst_encode_box_autoadd_ln_url_withdraw_success_data(apiObj.data);
wireObj.tag = 1;
wireObj.kind.Timeout.data = pre_data;
return;
}
if (apiObj is LnUrlWithdrawResult_ErrorStatus) {
var pre_data = cst_encode_box_autoadd_ln_url_error_data(apiObj.data);
wireObj.tag = 1;
wireObj.tag = 2;
wireObj.kind.ErrorStatus.data = pre_data;
return;
}
@@ -2009,6 +2047,13 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl<RustLibWire> {
wireObj.message = cst_encode_String(apiObj.message);
}
@protected
void cst_api_fill_to_wire_onchain_payment_limits_response(
OnchainPaymentLimitsResponse apiObj, wire_cst_onchain_payment_limits_response wireObj) {
cst_api_fill_to_wire_limits(apiObj.send, wireObj.send);
cst_api_fill_to_wire_limits(apiObj.receive, wireObj.receive);
}
@protected
void cst_api_fill_to_wire_pay_onchain_request(
PayOnchainRequest apiObj, wire_cst_pay_onchain_request wireObj) {
@@ -2530,6 +2575,13 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl<RustLibWire> {
@protected
void sse_encode_input_type(InputType self, SseSerializer serializer);
@protected
void sse_encode_lightning_payment_limits_response(
LightningPaymentLimitsResponse self, SseSerializer serializer);
@protected
void sse_encode_limits(Limits self, SseSerializer serializer);
@protected
void sse_encode_liquid_network(LiquidNetwork self, SseSerializer serializer);
@@ -2629,6 +2681,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl<RustLibWire> {
@protected
void sse_encode_network(Network self, SseSerializer serializer);
@protected
void sse_encode_onchain_payment_limits_response(
OnchainPaymentLimitsResponse self, SseSerializer serializer);
@protected
void sse_encode_opt_String(String? self, SseSerializer serializer);
@@ -2873,6 +2929,39 @@ class RustLibWire implements BaseWire {
late final _wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates =
_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_ratesPtr.asFunction<void Function(int, int)>();
void wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
int port_,
int that,
) {
return _wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
port_,
that,
);
}
late final _wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limitsPtr =
_lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr)>>(
'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits');
late final _wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits =
_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limitsPtr
.asFunction<void Function(int, int)>();
void wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
int port_,
int that,
) {
return _wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
port_,
that,
);
}
late final _wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limitsPtr =
_lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr)>>(
'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits');
late final _wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits =
_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limitsPtr.asFunction<void Function(int, int)>();
void wire__crate__bindings__BindingLiquidSdk_get_info(
int port_,
int that,
@@ -4506,6 +4595,23 @@ final class wire_cst_input_type extends ffi.Struct {
external InputTypeKind kind;
}
final class wire_cst_limits extends ffi.Struct {
@ffi.Uint64()
external int min_sat;
@ffi.Uint64()
external int max_sat;
@ffi.Uint64()
external int max_zero_conf_sat;
}
final class wire_cst_lightning_payment_limits_response extends ffi.Struct {
external wire_cst_limits send;
external wire_cst_limits receive;
}
final class wire_cst_LiquidSdkError_Generic extends ffi.Struct {
external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}
@@ -4720,6 +4826,10 @@ final class wire_cst_LnUrlWithdrawResult_Ok extends ffi.Struct {
external ffi.Pointer<wire_cst_ln_url_withdraw_success_data> data;
}
final class wire_cst_LnUrlWithdrawResult_Timeout extends ffi.Struct {
external ffi.Pointer<wire_cst_ln_url_withdraw_success_data> data;
}
final class wire_cst_LnUrlWithdrawResult_ErrorStatus extends ffi.Struct {
external ffi.Pointer<wire_cst_ln_url_error_data> data;
}
@@ -4727,6 +4837,8 @@ final class wire_cst_LnUrlWithdrawResult_ErrorStatus extends ffi.Struct {
final class LnUrlWithdrawResultKind extends ffi.Union {
external wire_cst_LnUrlWithdrawResult_Ok Ok;
external wire_cst_LnUrlWithdrawResult_Timeout Timeout;
external wire_cst_LnUrlWithdrawResult_ErrorStatus ErrorStatus;
}
@@ -4743,6 +4855,12 @@ final class wire_cst_log_entry extends ffi.Struct {
external ffi.Pointer<wire_cst_list_prim_u_8_strict> level;
}
final class wire_cst_onchain_payment_limits_response extends ffi.Struct {
external wire_cst_limits send;
external wire_cst_limits receive;
}
final class wire_cst_PaymentError_Generic extends ffi.Struct {
external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

72
packages/dart/lib/src/model.dart
View File

@@ -138,6 +138,54 @@ class GetInfoResponse {
pubkey == other.pubkey;
}
class LightningPaymentLimitsResponse {
/// Amount limits for a Send Payment to be valid
final Limits send;
/// Amount limits for a Receive Payment to be valid
final Limits receive;
const LightningPaymentLimitsResponse({
required this.send,
required this.receive,
});
@override
int get hashCode => send.hashCode ^ receive.hashCode;
@override
bool operator ==(Object other) =>
identical(this, other) ||
other is LightningPaymentLimitsResponse &&
runtimeType == other.runtimeType &&
send == other.send &&
receive == other.receive;
}
class Limits {
final BigInt minSat;
final BigInt maxSat;
final BigInt maxZeroConfSat;
const Limits({
required this.minSat,
required this.maxSat,
required this.maxZeroConfSat,
});
@override
int get hashCode => minSat.hashCode ^ maxSat.hashCode ^ maxZeroConfSat.hashCode;
@override
bool operator ==(Object other) =>
identical(this, other) ||
other is Limits &&
runtimeType == other.runtimeType &&
minSat == other.minSat &&
maxSat == other.maxSat &&
maxZeroConfSat == other.maxZeroConfSat;
}
/// Network chosen for this Liquid SDK instance. Note that it represents both the Liquid and the
/// Bitcoin network used.
enum LiquidNetwork {
@@ -229,6 +277,30 @@ class LogEntry {
other is LogEntry && runtimeType == other.runtimeType && line == other.line && level == other.level;
}
class OnchainPaymentLimitsResponse {
/// Amount limits for a Send Onchain Payment to be valid
final Limits send;
/// Amount limits for a Receive Onchain Payment to be valid
final Limits receive;
const OnchainPaymentLimitsResponse({
required this.send,
required this.receive,
});
@override
int get hashCode => send.hashCode ^ receive.hashCode;
@override
bool operator ==(Object other) =>
identical(this, other) ||
other is OnchainPaymentLimitsResponse &&
runtimeType == other.runtimeType &&
send == other.send &&
receive == other.receive;
}
class PayOnchainRequest {
final String address;
final PreparePayOnchainResponse prepareRes;

63
packages/flutter/lib/flutter_breez_liquid_bindings_generated.dart
View File

@@ -124,6 +124,40 @@ class FlutterBreezLiquidBindings {
_frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_ratesPtr
.asFunction<void Function(int, int)>();
void frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
int port_,
int that,
) {
return _frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
port_,
that,
);
}
late final _frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limitsPtr =
_lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr)>>(
'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits');
late final _frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits =
_frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limitsPtr
.asFunction<void Function(int, int)>();
void frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
int port_,
int that,
) {
return _frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
port_,
that,
);
}
late final _frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limitsPtr =
_lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr)>>(
'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits');
late final _frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits =
_frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limitsPtr
.asFunction<void Function(int, int)>();
void frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info(
int port_,
int that,
@@ -1829,6 +1863,23 @@ final class wire_cst_input_type extends ffi.Struct {
external InputTypeKind kind;
}
final class wire_cst_limits extends ffi.Struct {
@ffi.Uint64()
external int min_sat;
@ffi.Uint64()
external int max_sat;
@ffi.Uint64()
external int max_zero_conf_sat;
}
final class wire_cst_lightning_payment_limits_response extends ffi.Struct {
external wire_cst_limits send;
external wire_cst_limits receive;
}
final class wire_cst_LiquidSdkError_Generic extends ffi.Struct {
external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}
@@ -2043,6 +2094,10 @@ final class wire_cst_LnUrlWithdrawResult_Ok extends ffi.Struct {
external ffi.Pointer<wire_cst_ln_url_withdraw_success_data> data;
}
final class wire_cst_LnUrlWithdrawResult_Timeout extends ffi.Struct {
external ffi.Pointer<wire_cst_ln_url_withdraw_success_data> data;
}
final class wire_cst_LnUrlWithdrawResult_ErrorStatus extends ffi.Struct {
external ffi.Pointer<wire_cst_ln_url_error_data> data;
}
@@ -2050,6 +2105,8 @@ final class wire_cst_LnUrlWithdrawResult_ErrorStatus extends ffi.Struct {
final class LnUrlWithdrawResultKind extends ffi.Union {
external wire_cst_LnUrlWithdrawResult_Ok Ok;
external wire_cst_LnUrlWithdrawResult_Timeout Timeout;
external wire_cst_LnUrlWithdrawResult_ErrorStatus ErrorStatus;
}
@@ -2066,6 +2123,12 @@ final class wire_cst_log_entry extends ffi.Struct {
external ffi.Pointer<wire_cst_list_prim_u_8_strict> level;
}
final class wire_cst_onchain_payment_limits_response extends ffi.Struct {
external wire_cst_limits send;
external wire_cst_limits receive;
}
final class wire_cst_PaymentError_Generic extends ffi.Struct {
external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

119
packages/react-native/android/src/main/java/com/breezliquidsdk/BreezLiquidSDKMapper.kt
View File

@@ -420,6 +420,82 @@ fun asLnInvoiceList(arr: ReadableArray): List<LnInvoice> {
return list
}
fun asLightningPaymentLimitsResponse(lightningPaymentLimitsResponse: ReadableMap): LightningPaymentLimitsResponse? {
if (!validateMandatoryFields(
lightningPaymentLimitsResponse,
arrayOf(
"send",
"receive",
),
)
) {
return null
}
val send = lightningPaymentLimitsResponse.getMap("send")?.let { asLimits(it) }!!
val receive = lightningPaymentLimitsResponse.getMap("receive")?.let { asLimits(it) }!!
return LightningPaymentLimitsResponse(
send,
receive,
)
}
fun readableMapOf(lightningPaymentLimitsResponse: LightningPaymentLimitsResponse): ReadableMap =
readableMapOf(
"send" to readableMapOf(lightningPaymentLimitsResponse.send),
"receive" to readableMapOf(lightningPaymentLimitsResponse.receive),
)
fun asLightningPaymentLimitsResponseList(arr: ReadableArray): List<LightningPaymentLimitsResponse> {
val list = ArrayList<LightningPaymentLimitsResponse>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asLightningPaymentLimitsResponse(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asLimits(limits: ReadableMap): Limits? {
if (!validateMandatoryFields(
limits,
arrayOf(
"minSat",
"maxSat",
"maxZeroConfSat",
),
)
) {
return null
}
val minSat = limits.getDouble("minSat").toULong()
val maxSat = limits.getDouble("maxSat").toULong()
val maxZeroConfSat = limits.getDouble("maxZeroConfSat").toULong()
return Limits(
minSat,
maxSat,
maxZeroConfSat,
)
}
fun readableMapOf(limits: Limits): ReadableMap =
readableMapOf(
"minSat" to limits.minSat,
"maxSat" to limits.maxSat,
"maxZeroConfSat" to limits.maxZeroConfSat,
)
fun asLimitsList(arr: ReadableArray): List<Limits> {
val list = ArrayList<Limits>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asLimits(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asLnUrlAuthRequestData(lnUrlAuthRequestData: ReadableMap): LnUrlAuthRequestData? {
if (!validateMandatoryFields(
lnUrlAuthRequestData,
@@ -939,6 +1015,42 @@ fun asMessageSuccessActionDataList(arr: ReadableArray): List<MessageSuccessActio
return list
}
fun asOnchainPaymentLimitsResponse(onchainPaymentLimitsResponse: ReadableMap): OnchainPaymentLimitsResponse? {
if (!validateMandatoryFields(
onchainPaymentLimitsResponse,
arrayOf(
"send",
"receive",
),
)
) {
return null
}
val send = onchainPaymentLimitsResponse.getMap("send")?.let { asLimits(it) }!!
val receive = onchainPaymentLimitsResponse.getMap("receive")?.let { asLimits(it) }!!
return OnchainPaymentLimitsResponse(
send,
receive,
)
}
fun readableMapOf(onchainPaymentLimitsResponse: OnchainPaymentLimitsResponse): ReadableMap =
readableMapOf(
"send" to readableMapOf(onchainPaymentLimitsResponse.send),
"receive" to readableMapOf(onchainPaymentLimitsResponse.receive),
)
fun asOnchainPaymentLimitsResponseList(arr: ReadableArray): List<OnchainPaymentLimitsResponse> {
val list = ArrayList<OnchainPaymentLimitsResponse>()
for (value in arr.toArrayList()) {
when (value) {
is ReadableMap -> list.add(asOnchainPaymentLimitsResponse(value)!!)
else -> throw LiquidSdkException.Generic(errUnexpectedType("${value::class.java.name}"))
}
}
return list
}
fun asPayOnchainRequest(payOnchainRequest: ReadableMap): PayOnchainRequest? {
if (!validateMandatoryFields(
payOnchainRequest,
@@ -2128,6 +2240,9 @@ fun asLnUrlWithdrawResult(lnUrlWithdrawResult: ReadableMap): LnUrlWithdrawResult
if (type == "ok") {
return LnUrlWithdrawResult.Ok(lnUrlWithdrawResult.getMap("data")?.let { asLnUrlWithdrawSuccessData(it) }!!)
}
if (type == "timeout") {
return LnUrlWithdrawResult.Timeout(lnUrlWithdrawResult.getMap("data")?.let { asLnUrlWithdrawSuccessData(it) }!!)
}
if (type == "errorStatus") {
return LnUrlWithdrawResult.ErrorStatus(lnUrlWithdrawResult.getMap("data")?.let { asLnUrlErrorData(it) }!!)
}
@@ -2141,6 +2256,10 @@ fun readableMapOf(lnUrlWithdrawResult: LnUrlWithdrawResult): ReadableMap? {
pushToMap(map, "type", "ok")
pushToMap(map, "data", readableMapOf(lnUrlWithdrawResult.data))
}
is LnUrlWithdrawResult.Timeout -> {
pushToMap(map, "type", "timeout")
pushToMap(map, "data", readableMapOf(lnUrlWithdrawResult.data))
}
is LnUrlWithdrawResult.ErrorStatus -> {
pushToMap(map, "type", "errorStatus")
pushToMap(map, "data", readableMapOf(lnUrlWithdrawResult.data))

24
packages/react-native/android/src/main/java/com/breezliquidsdk/BreezLiquidSDKModule.kt
View File

@@ -258,6 +258,30 @@ class BreezLiquidSDKModule(
}
}
@ReactMethod
fun fetchLightningLimits(promise: Promise) {
executor.execute {
try {
val res = getBindingLiquidSdk().fetchLightningLimits()
promise.resolve(readableMapOf(res))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun fetchOnchainLimits(promise: Promise) {
executor.execute {
try {
val res = getBindingLiquidSdk().fetchOnchainLimits()
promise.resolve(readableMapOf(res))
} catch (e: Exception) {
promise.reject(e.javaClass.simpleName.replace("Exception", "Error"), e.message, e)
}
}
}
@ReactMethod
fun preparePayOnchain(
req: ReadableMap,

141
packages/react-native/ios/BreezLiquidSDKMapper.swift
View File

@@ -517,6 +517,90 @@ enum BreezLiquidSDKMapper {
return lnInvoiceList.map { v -> [String: Any?] in dictionaryOf(lnInvoice: v) }
}
static func asLightningPaymentLimitsResponse(lightningPaymentLimitsResponse: [String: Any?]) throws -> LightningPaymentLimitsResponse {
guard let sendTmp = lightningPaymentLimitsResponse["send"] as? [String: Any?] else {
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "send", typeName: "LightningPaymentLimitsResponse"))
}
let send = try asLimits(limits: sendTmp)
guard let receiveTmp = lightningPaymentLimitsResponse["receive"] as? [String: Any?] else {
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "receive", typeName: "LightningPaymentLimitsResponse"))
}
let receive = try asLimits(limits: receiveTmp)
return LightningPaymentLimitsResponse(
send: send,
receive: receive
)
}
static func dictionaryOf(lightningPaymentLimitsResponse: LightningPaymentLimitsResponse) -> [String: Any?] {
return [
"send": dictionaryOf(limits: lightningPaymentLimitsResponse.send),
"receive": dictionaryOf(limits: lightningPaymentLimitsResponse.receive),
]
}
static func asLightningPaymentLimitsResponseList(arr: [Any]) throws -> [LightningPaymentLimitsResponse] {
var list = [LightningPaymentLimitsResponse]()
for value in arr {
if let val = value as? [String: Any?] {
var lightningPaymentLimitsResponse = try asLightningPaymentLimitsResponse(lightningPaymentLimitsResponse: val)
list.append(lightningPaymentLimitsResponse)
} else {
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "LightningPaymentLimitsResponse"))
}
}
return list
}
static func arrayOf(lightningPaymentLimitsResponseList: [LightningPaymentLimitsResponse]) -> [Any] {
return lightningPaymentLimitsResponseList.map { v -> [String: Any?] in dictionaryOf(lightningPaymentLimitsResponse: v) }
}
static func asLimits(limits: [String: Any?]) throws -> Limits {
guard let minSat = limits["minSat"] as? UInt64 else {
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "minSat", typeName: "Limits"))
}
guard let maxSat = limits["maxSat"] as? UInt64 else {
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "maxSat", typeName: "Limits"))
}
guard let maxZeroConfSat = limits["maxZeroConfSat"] as? UInt64 else {
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "maxZeroConfSat", typeName: "Limits"))
}
return Limits(
minSat: minSat,
maxSat: maxSat,
maxZeroConfSat: maxZeroConfSat
)
}
static func dictionaryOf(limits: Limits) -> [String: Any?] {
return [
"minSat": limits.minSat,
"maxSat": limits.maxSat,
"maxZeroConfSat": limits.maxZeroConfSat,
]
}
static func asLimitsList(arr: [Any]) throws -> [Limits] {
var list = [Limits]()
for value in arr {
if let val = value as? [String: Any?] {
var limits = try asLimits(limits: val)
list.append(limits)
} else {
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "Limits"))
}
}
return list
}
static func arrayOf(limitsList: [Limits]) -> [Any] {
return limitsList.map { v -> [String: Any?] in dictionaryOf(limits: v) }
}
static func asLnUrlAuthRequestData(lnUrlAuthRequestData: [String: Any?]) throws -> LnUrlAuthRequestData {
guard let k1 = lnUrlAuthRequestData["k1"] as? String else {
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "k1", typeName: "LnUrlAuthRequestData"))
@@ -1110,6 +1194,47 @@ enum BreezLiquidSDKMapper {
return messageSuccessActionDataList.map { v -> [String: Any?] in dictionaryOf(messageSuccessActionData: v) }
}
static func asOnchainPaymentLimitsResponse(onchainPaymentLimitsResponse: [String: Any?]) throws -> OnchainPaymentLimitsResponse {
guard let sendTmp = onchainPaymentLimitsResponse["send"] as? [String: Any?] else {
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "send", typeName: "OnchainPaymentLimitsResponse"))
}
let send = try asLimits(limits: sendTmp)
guard let receiveTmp = onchainPaymentLimitsResponse["receive"] as? [String: Any?] else {
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "receive", typeName: "OnchainPaymentLimitsResponse"))
}
let receive = try asLimits(limits: receiveTmp)
return OnchainPaymentLimitsResponse(
send: send,
receive: receive
)
}
static func dictionaryOf(onchainPaymentLimitsResponse: OnchainPaymentLimitsResponse) -> [String: Any?] {
return [
"send": dictionaryOf(limits: onchainPaymentLimitsResponse.send),
"receive": dictionaryOf(limits: onchainPaymentLimitsResponse.receive),
]
}
static func asOnchainPaymentLimitsResponseList(arr: [Any]) throws -> [OnchainPaymentLimitsResponse] {
var list = [OnchainPaymentLimitsResponse]()
for value in arr {
if let val = value as? [String: Any?] {
var onchainPaymentLimitsResponse = try asOnchainPaymentLimitsResponse(onchainPaymentLimitsResponse: val)
list.append(onchainPaymentLimitsResponse)
} else {
throw LiquidSdkError.Generic(message: errUnexpectedType(typeName: "OnchainPaymentLimitsResponse"))
}
}
return list
}
static func arrayOf(onchainPaymentLimitsResponseList: [OnchainPaymentLimitsResponse]) -> [Any] {
return onchainPaymentLimitsResponseList.map { v -> [String: Any?] in dictionaryOf(onchainPaymentLimitsResponse: v) }
}
static func asPayOnchainRequest(payOnchainRequest: [String: Any?]) throws -> PayOnchainRequest {
guard let address = payOnchainRequest["address"] as? String else {
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "address", typeName: "PayOnchainRequest"))
@@ -2650,6 +2775,14 @@ enum BreezLiquidSDKMapper {
return LnUrlWithdrawResult.ok(data: _data)
}
if type == "timeout" {
guard let dataTmp = lnUrlWithdrawResult["data"] as? [String: Any?] else {
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "data", typeName: "LnUrlWithdrawResult"))
}
let _data = try asLnUrlWithdrawSuccessData(lnUrlWithdrawSuccessData: dataTmp)
return LnUrlWithdrawResult.timeout(data: _data)
}
if type == "errorStatus" {
guard let dataTmp = lnUrlWithdrawResult["data"] as? [String: Any?] else {
throw LiquidSdkError.Generic(message: errMissingMandatoryField(fieldName: "data", typeName: "LnUrlWithdrawResult"))
@@ -2672,6 +2805,14 @@ enum BreezLiquidSDKMapper {
"data": dictionaryOf(lnUrlWithdrawSuccessData: data),
]
case let .timeout(
data
):
return [
"type": "timeout",
"data": dictionaryOf(lnUrlWithdrawSuccessData: data),
]
case let .errorStatus(
data
):

10
packages/react-native/ios/RNBreezLiquidSDK.m
View File

@@ -72,6 +72,16 @@ RCT_EXTERN_METHOD(
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
fetchLightningLimits: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
fetchOnchainLimits: (RCTPromiseResolveBlock)resolve
reject: (RCTPromiseRejectBlock)reject
)
RCT_EXTERN_METHOD(
preparePayOnchain: (NSDictionary*)req
resolve: (RCTPromiseResolveBlock)resolve

20
packages/react-native/ios/RNBreezLiquidSDK.swift
View File

@@ -208,6 +208,26 @@ class RNBreezLiquidSDK: RCTEventEmitter {
}
}
@objc(fetchLightningLimits:reject:)
func fetchLightningLimits(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
var res = try getBindingLiquidSdk().fetchLightningLimits()
resolve(BreezLiquidSDKMapper.dictionaryOf(lightningPaymentLimitsResponse: res))
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(fetchOnchainLimits:reject:)
func fetchOnchainLimits(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {
var res = try getBindingLiquidSdk().fetchOnchainLimits()
resolve(BreezLiquidSDKMapper.dictionaryOf(onchainPaymentLimitsResponse: res))
} catch let err {
rejectErr(err: err, reject: reject)
}
}
@objc(preparePayOnchain:resolve:reject:)
func preparePayOnchain(_ req: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
do {

30
packages/react-native/src/index.ts
View File

@@ -88,6 +88,17 @@ export interface LnInvoice {
minFinalCltvExpiryDelta: number
}
export interface LightningPaymentLimitsResponse {
send: Limits
receive: Limits
}
export interface Limits {
minSat: number
maxSat: number
maxZeroConfSat: number
}
export interface LnUrlAuthRequestData {
k1: string
domain: string
@@ -166,6 +177,11 @@ export interface MessageSuccessActionData {
message: string
}
export interface OnchainPaymentLimitsResponse {
send: Limits
receive: Limits
}
export interface PayOnchainRequest {
address: string
prepareRes: PreparePayOnchainResponse
@@ -416,12 +432,16 @@ export type LnUrlPayResult = {
export enum LnUrlWithdrawResultVariant {
OK = "ok",
TIMEOUT = "timeout",
ERROR_STATUS = "errorStatus"
}
export type LnUrlWithdrawResult = {
type: LnUrlWithdrawResultVariant.OK,
data: LnUrlWithdrawSuccessData
} | {
type: LnUrlWithdrawResultVariant.TIMEOUT,
data: LnUrlWithdrawSuccessData
} | {
type: LnUrlWithdrawResultVariant.ERROR_STATUS,
data: LnUrlErrorData
@@ -537,6 +557,16 @@ export const receivePayment = async (req: PrepareReceiveResponse): Promise<Recei
return response
}
export const fetchLightningLimits = async (): Promise<LightningPaymentLimitsResponse> => {
const response = await BreezLiquidSDK.fetchLightningLimits()
return response
}
export const fetchOnchainLimits = async (): Promise<OnchainPaymentLimitsResponse> => {
const response = await BreezLiquidSDK.fetchOnchainLimits()
return response
}
export const preparePayOnchain = async (req: PreparePayOnchainRequest): Promise<PreparePayOnchainResponse> => {
const response = await BreezLiquidSDK.preparePayOnchain(req)
return response