Add zero-amount Receive Chain Swap

cli/src/commands.rs

@@ -263,13 +263,21 @@ pub(crate) async fn handle_command(
                 })
                 .await?;
 
-            wait_confirmation!(
-                format!(
-                    "Fees: {} sat. Are the fees acceptable? (y/N) ",
-                    prepare_response.fees_sat
-                ),
-                "Payment receive halted"
-            );
+            let fees = prepare_response.fees_sat;
+            let confirmation_msg = match payer_amount_sat {
+                Some(_) => format!("Fees: {fees} sat. Are the fees acceptable? (y/N)"),
+                None => {
+                    let min = prepare_response.zero_amount_min_payer_amount_sat.unwrap();
+                    let max = prepare_response.zero_amount_max_payer_amount_sat.unwrap();
+                    let service_feerate = prepare_response.zero_amount_service_feerate.unwrap();
+                    format!(
+                        "Fees: {fees} sat + {service_feerate}% of the sent amount. \
+                        Sender should send between {min} sat and {max} sat. \
+                        Are the fees acceptable? (y/N)"
+                    )
+                }
+            };
+            wait_confirmation!(confirmation_msg, "Payment receive halted");
 
             let response = sdk
                 .receive_payment(&ReceivePaymentRequest {

lib/bindings/langs/flutter/breez_sdk_liquid/include/breez_sdk_liquid.h

@@ -317,6 +317,9 @@ typedef struct wire_cst_prepare_receive_response {
   int32_t payment_method;
   uint64_t *payer_amount_sat;
   uint64_t fees_sat;
+  uint64_t *zero_amount_min_payer_amount_sat;
+  uint64_t *zero_amount_max_payer_amount_sat;
+  double *zero_amount_service_feerate;
 } wire_cst_prepare_receive_response;
 
 typedef struct wire_cst_receive_payment_request {
@@ -1134,6 +1137,8 @@ struct wire_cst_check_message_request *frbgen_breez_liquid_cst_new_box_autoadd_c
 
 struct wire_cst_connect_request *frbgen_breez_liquid_cst_new_box_autoadd_connect_request(void);
 
+double *frbgen_breez_liquid_cst_new_box_autoadd_f_64(double value);
+
 struct wire_cst_get_payment_request *frbgen_breez_liquid_cst_new_box_autoadd_get_payment_request(void);
 
 int64_t *frbgen_breez_liquid_cst_new_box_autoadd_i_64(int64_t value);
@@ -1237,6 +1242,7 @@ static int64_t dummy_method_to_enforce_bundling(void) {
     dummy_var ^= ((int64_t) (void*) frbgen_breez_liquid_cst_new_box_autoadd_buy_bitcoin_request);
     dummy_var ^= ((int64_t) (void*) frbgen_breez_liquid_cst_new_box_autoadd_check_message_request);
     dummy_var ^= ((int64_t) (void*) frbgen_breez_liquid_cst_new_box_autoadd_connect_request);
+    dummy_var ^= ((int64_t) (void*) frbgen_breez_liquid_cst_new_box_autoadd_f_64);
     dummy_var ^= ((int64_t) (void*) frbgen_breez_liquid_cst_new_box_autoadd_get_payment_request);
     dummy_var ^= ((int64_t) (void*) frbgen_breez_liquid_cst_new_box_autoadd_i_64);
     dummy_var ^= ((int64_t) (void*) frbgen_breez_liquid_cst_new_box_autoadd_liquid_address_data);

lib/bindings/src/breez_sdk_liquid.udl

@@ -407,9 +407,12 @@ dictionary PrepareReceiveRequest {
 };
 
 dictionary PrepareReceiveResponse {
-    u64? payer_amount_sat;
     PaymentMethod payment_method;
     u64 fees_sat;
+    u64? payer_amount_sat;
+    u64? zero_amount_min_payer_amount_sat;
+    u64? zero_amount_max_payer_amount_sat;
+    f64? zero_amount_service_feerate;
 };
 
 dictionary ReceivePaymentRequest {

lib/core/Cargo.toml

@@ -14,7 +14,8 @@ frb = ["dep:flutter_rust_bridge"]
 [dependencies]
 anyhow = { workspace = true }
 bip39 = "2.0.0"
-boltz-client = { git = "https://github.com/SatoshiPortal/boltz-rust", branch = "trunk" }
+#boltz-client = { git = "https://github.com/SatoshiPortal/boltz-rust", branch = "trunk" }
+boltz-client = { git = "https://github.com/ok300/boltz-rust", branch = "ok300-support-quote" }
 chrono = "0.4"
 env_logger = "0.11"
 flutter_rust_bridge = { version = "=2.4.0", features = [

lib/core/src/chain_swap.rs

@@ -367,6 +367,28 @@ impl ChainSwapHandler {
             | ChainSwapStates::TransactionLockupFailed
             | ChainSwapStates::TransactionRefunded
             | ChainSwapStates::SwapExpired => {
+                // Zero-amount Receive Chain Swaps also get to TransactionLockupFailed when user locks up funds
+                let is_zero_amount = swap.payer_amount_sat == 0;
+                if matches!(swap_state, ChainSwapStates::TransactionLockupFailed) && is_zero_amount
+                {
+                    if let Err(e) = self
+                        .swapper
+                        .get_zero_amount_chain_swap_quote(&swap.id)
+                        .map(|quote| quote.to_sat())
+                        .and_then(|quote| {
+                            info!("Got quote of {quote} sat for swap {}", &swap.id);
+
+                            self.swapper
+                                .accept_zero_amount_chain_swap_quote(&swap.id, quote)
+                        })
+                    {
+                        warn!("Failed to accept the quote for swap {}: {e:?}", &swap.id);
+                    }
+
+                    // We successfully accepted the quote, the swap should continue as normal
+                    return Ok(()); // Break from TxLockupFailed branch
+                }
+
                 match swap.refund_tx_id.clone() {
                     None => {
                         warn!("Chain Swap {id} is in an unrecoverable state: {swap_state:?}");
@@ -384,7 +406,7 @@ impl ChainSwapHandler {
                         }
                     }
                     Some(refund_tx_id) => warn!(
-                        "Refund tx for Chain Swap {id} was already broadcast: txid {refund_tx_id}"
+                        "Refund for Chain Swap {id} was already broadcast: txid {refund_tx_id}"
                     ),
                 };
                 Ok(())

lib/core/src/frb_generated.rs

@@ -3158,6 +3158,17 @@ impl SseDecode for Option<bool> {
     }
 }
 
+impl SseDecode for Option<f64> {
+    // 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(<f64>::sse_decode(deserializer));
+        } else {
+            return None;
+        }
+    }
+}
+
 impl SseDecode for Option<i64> {
     // Codec=Sse (Serialization based), see doc to use other codecs
     fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
@@ -3599,10 +3610,16 @@ impl SseDecode for crate::model::PrepareReceiveResponse {
         let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
         let mut var_payerAmountSat = <Option<u64>>::sse_decode(deserializer);
         let mut var_feesSat = <u64>::sse_decode(deserializer);
+        let mut var_zeroAmountMinPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
+        let mut var_zeroAmountMaxPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
+        let mut var_zeroAmountServiceFeerate = <Option<f64>>::sse_decode(deserializer);
         return crate::model::PrepareReceiveResponse {
             payment_method: var_paymentMethod,
             payer_amount_sat: var_payerAmountSat,
             fees_sat: var_feesSat,
+            zero_amount_min_payer_amount_sat: var_zeroAmountMinPayerAmountSat,
+            zero_amount_max_payer_amount_sat: var_zeroAmountMaxPayerAmountSat,
+            zero_amount_service_feerate: var_zeroAmountServiceFeerate,
         };
     }
 }
@@ -5572,6 +5589,15 @@ impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveResponse {
             self.payment_method.into_into_dart().into_dart(),
             self.payer_amount_sat.into_into_dart().into_dart(),
             self.fees_sat.into_into_dart().into_dart(),
+            self.zero_amount_min_payer_amount_sat
+                .into_into_dart()
+                .into_dart(),
+            self.zero_amount_max_payer_amount_sat
+                .into_into_dart()
+                .into_dart(),
+            self.zero_amount_service_feerate
+                .into_into_dart()
+                .into_dart(),
         ]
         .into_dart()
     }
@@ -6959,6 +6985,16 @@ impl SseEncode for Option<bool> {
     }
 }
 
+impl SseEncode for Option<f64> {
+    // 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 {
+            <f64>::sse_encode(value, serializer);
+        }
+    }
+}
+
 impl SseEncode for Option<i64> {
     // Codec=Sse (Serialization based), see doc to use other codecs
     fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
@@ -7344,6 +7380,9 @@ impl SseEncode for crate::model::PrepareReceiveResponse {
         <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
         <Option<u64>>::sse_encode(self.payer_amount_sat, serializer);
         <u64>::sse_encode(self.fees_sat, serializer);
+        <Option<u64>>::sse_encode(self.zero_amount_min_payer_amount_sat, serializer);
+        <Option<u64>>::sse_encode(self.zero_amount_max_payer_amount_sat, serializer);
+        <Option<f64>>::sse_encode(self.zero_amount_service_feerate, serializer);
     }
 }
 
@@ -7918,6 +7957,12 @@ mod io {
             CstDecode::<crate::model::ConnectRequest>::cst_decode(*wrap).into()
         }
     }
+    impl CstDecode<f64> for *mut f64 {
+        // Codec=Cst (C-struct based), see doc to use other codecs
+        fn cst_decode(self) -> f64 {
+            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
+        }
+    }
     impl CstDecode<crate::model::GetPaymentRequest> for *mut wire_cst_get_payment_request {
         // Codec=Cst (C-struct based), see doc to use other codecs
         fn cst_decode(self) -> crate::model::GetPaymentRequest {
@@ -9114,6 +9159,13 @@ mod io {
                 payment_method: self.payment_method.cst_decode(),
                 payer_amount_sat: self.payer_amount_sat.cst_decode(),
                 fees_sat: self.fees_sat.cst_decode(),
+                zero_amount_min_payer_amount_sat: self
+                    .zero_amount_min_payer_amount_sat
+                    .cst_decode(),
+                zero_amount_max_payer_amount_sat: self
+                    .zero_amount_max_payer_amount_sat
+                    .cst_decode(),
+                zero_amount_service_feerate: self.zero_amount_service_feerate.cst_decode(),
             }
         }
     }
@@ -10209,6 +10261,9 @@ mod io {
                 payment_method: Default::default(),
                 payer_amount_sat: core::ptr::null_mut(),
                 fees_sat: Default::default(),
+                zero_amount_min_payer_amount_sat: core::ptr::null_mut(),
+                zero_amount_max_payer_amount_sat: core::ptr::null_mut(),
+                zero_amount_service_feerate: core::ptr::null_mut(),
             }
         }
     }
@@ -10983,6 +11038,11 @@ mod io {
         )
     }
 
+    #[no_mangle]
+    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_f_64(value: f64) -> *mut f64 {
+        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
+    }
+
     #[no_mangle]
     pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_get_payment_request(
     ) -> *mut wire_cst_get_payment_request {
@@ -12239,6 +12299,9 @@ mod io {
         payment_method: i32,
         payer_amount_sat: *mut u64,
         fees_sat: u64,
+        zero_amount_min_payer_amount_sat: *mut u64,
+        zero_amount_max_payer_amount_sat: *mut u64,
+        zero_amount_service_feerate: *mut f64,
     }
     #[repr(C)]
     #[derive(Clone, Copy)]

lib/core/src/model.rs

@@ -295,6 +295,21 @@ pub struct PrepareReceiveResponse {
     pub payment_method: PaymentMethod,
     pub payer_amount_sat: Option<u64>,
     pub fees_sat: u64,
+
+    /// The minimum amount the payer can send for this swap to succeed.
+    ///
+    /// Only applicable to Zero-Amount Receive Chain Swaps.
+    pub zero_amount_min_payer_amount_sat: Option<u64>,
+
+    /// The maximum amount the payer can send for this swap to succeed.
+    ///
+    /// Only applicable to Zero-Amount Receive Chain Swaps.
+    pub zero_amount_max_payer_amount_sat: Option<u64>,
+
+    /// The percentage of the sent amount that will count towards the service fee.
+    ///
+    /// Only applicable to Zero-Amount Receive Chain Swaps.
+    pub zero_amount_service_feerate: Option<f64>,
 }
 
 /// An argument when calling [crate::sdk::LiquidSdk::receive_payment].