feat: add main sdk hook

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

@@ -442,6 +442,7 @@ typedef struct wire_cst_config {
   int32_t network;
   uint64_t payment_timeout_sec;
   uint32_t zero_conf_min_fee_rate_msat;
+  struct wire_cst_list_prim_u_8_strict *sync_service_url;
   uint64_t *zero_conf_max_amount_sat;
   struct wire_cst_list_prim_u_8_strict *breez_api_key;
 } wire_cst_config;

lib/bindings/src/breez_sdk_liquid.udl

@@ -310,6 +310,7 @@ dictionary Config {
     LiquidNetwork network;
     u64 payment_timeout_sec;
     u32 zero_conf_min_fee_rate_msat;
+    string sync_service_url;
     string? breez_api_key;
     u64? zero_conf_max_amount_sat;
 };

lib/core/src/frb_generated.rs

@@ -2286,6 +2286,7 @@ impl SseDecode for crate::model::Config {
         let mut var_network = <crate::model::LiquidNetwork>::sse_decode(deserializer);
         let mut var_paymentTimeoutSec = <u64>::sse_decode(deserializer);
         let mut var_zeroConfMinFeeRateMsat = <u32>::sse_decode(deserializer);
+        let mut var_syncServiceUrl = <String>::sse_decode(deserializer);
         let mut var_zeroConfMaxAmountSat = <Option<u64>>::sse_decode(deserializer);
         let mut var_breezApiKey = <Option<String>>::sse_decode(deserializer);
         return crate::model::Config {
@@ -2296,6 +2297,7 @@ impl SseDecode for crate::model::Config {
             network: var_network,
             payment_timeout_sec: var_paymentTimeoutSec,
             zero_conf_min_fee_rate_msat: var_zeroConfMinFeeRateMsat,
+            sync_service_url: var_syncServiceUrl,
             zero_conf_max_amount_sat: var_zeroConfMaxAmountSat,
             breez_api_key: var_breezApiKey,
         };
@@ -4318,6 +4320,7 @@ impl flutter_rust_bridge::IntoDart for crate::model::Config {
             self.zero_conf_min_fee_rate_msat
                 .into_into_dart()
                 .into_dart(),
+            self.sync_service_url.into_into_dart().into_dart(),
             self.zero_conf_max_amount_sat.into_into_dart().into_dart(),
             self.breez_api_key.into_into_dart().into_dart(),
         ]
@@ -6290,6 +6293,7 @@ impl SseEncode for crate::model::Config {
         <crate::model::LiquidNetwork>::sse_encode(self.network, serializer);
         <u64>::sse_encode(self.payment_timeout_sec, serializer);
         <u32>::sse_encode(self.zero_conf_min_fee_rate_msat, serializer);
+        <String>::sse_encode(self.sync_service_url, serializer);
         <Option<u64>>::sse_encode(self.zero_conf_max_amount_sat, serializer);
         <Option<String>>::sse_encode(self.breez_api_key, serializer);
     }
@@ -8216,6 +8220,7 @@ mod io {
                 network: self.network.cst_decode(),
                 payment_timeout_sec: self.payment_timeout_sec.cst_decode(),
                 zero_conf_min_fee_rate_msat: self.zero_conf_min_fee_rate_msat.cst_decode(),
+                sync_service_url: self.sync_service_url.cst_decode(),
                 zero_conf_max_amount_sat: self.zero_conf_max_amount_sat.cst_decode(),
                 breez_api_key: self.breez_api_key.cst_decode(),
             }
@@ -9573,6 +9578,7 @@ mod io {
                 network: Default::default(),
                 payment_timeout_sec: Default::default(),
                 zero_conf_min_fee_rate_msat: Default::default(),
+                sync_service_url: core::ptr::null_mut(),
                 zero_conf_max_amount_sat: core::ptr::null_mut(),
                 breez_api_key: core::ptr::null_mut(),
             }
@@ -11469,6 +11475,7 @@ mod io {
         network: i32,
         payment_timeout_sec: u64,
         zero_conf_min_fee_rate_msat: u32,
+        sync_service_url: *mut wire_cst_list_prim_u_8_strict,
         zero_conf_max_amount_sat: *mut u64,
         breez_api_key: *mut wire_cst_list_prim_u_8_strict,
     }

lib/core/src/model.rs

@@ -28,6 +28,7 @@ use crate::utils;
 // Both use f64 for the maximum precision when converting between units
 pub const STANDARD_FEE_RATE_SAT_PER_VBYTE: f64 = 0.1;
 pub const LOWBALL_FEE_RATE_SAT_PER_VBYTE: f64 = 0.01;
+const BREEZ_SYNC_SERVICE_URL: &str = "https://sync-service-wandering-morning-6267.fly.dev";
 
 /// Configuration for the Liquid SDK
 #[derive(Clone, Debug, Serialize)]
@@ -45,6 +46,8 @@ pub struct Config {
     pub payment_timeout_sec: u64,
     /// Zero-conf minimum accepted fee-rate in millisatoshis per vbyte
     pub zero_conf_min_fee_rate_msat: u32,
+    /// The url of the real-time sync service
+    pub sync_service_url: String,
     /// Maximum amount in satoshi to accept zero-conf payments with
     /// Defaults to [crate::receive_swap::DEFAULT_ZERO_CONF_MAX_SAT]
     pub zero_conf_max_amount_sat: Option<u64>,
@@ -62,6 +65,7 @@ impl Config {
             network: LiquidNetwork::Mainnet,
             payment_timeout_sec: 15,
             zero_conf_min_fee_rate_msat: DEFAULT_ZERO_CONF_MIN_FEE_RATE_MAINNET,
+            sync_service_url: BREEZ_SYNC_SERVICE_URL.to_string(),
             zero_conf_max_amount_sat: None,
             breez_api_key: Some(breez_api_key),
         }
@@ -76,6 +80,7 @@ impl Config {
             network: LiquidNetwork::Testnet,
             payment_timeout_sec: 15,
             zero_conf_min_fee_rate_msat: DEFAULT_ZERO_CONF_MIN_FEE_RATE_TESTNET,
+            sync_service_url: BREEZ_SYNC_SERVICE_URL.to_string(),
             zero_conf_max_amount_sat: None,
             breez_api_key,
         }

lib/core/src/sdk.rs

@@ -45,6 +45,9 @@ use crate::{
     utils, *,
 };
 
+use self::sync::client::BreezSyncerClient;
+use self::sync::SyncService;
+
 pub const DEFAULT_DATA_DIR: &str = ".data";
 /// Number of blocks to monitor a swap after its timeout block height
 pub const CHAIN_SWAP_MONITORING_PERIOD_BITCOIN_BLOCKS: u32 = 4320;
@@ -66,6 +69,7 @@ pub struct LiquidSdk {
     pub(crate) shutdown_sender: watch::Sender<()>,
     pub(crate) shutdown_receiver: watch::Receiver<()>,
     pub(crate) send_swap_handler: SendSwapHandler,
+    pub(crate) sync_service: Arc<SyncService>,
     pub(crate) receive_swap_handler: ReceiveSwapHandler,
     pub(crate) chain_swap_handler: Arc<ChainSwapHandler>,
     pub(crate) buy_bitcoin_service: Arc<dyn BuyBitcoinApi>,
@@ -205,6 +209,14 @@ impl LiquidSdk {
         let buy_bitcoin_service =
             Arc::new(BuyBitcoinService::new(config.clone(), breez_server.clone()));
 
+        let syncer_client = Box::new(BreezSyncerClient::new());
+        let sync_service = Arc::new(SyncService::new(
+            config.sync_service_url.clone(),
+            persister.clone(),
+            signer.clone(),
+            syncer_client,
+        ));
+
         let sdk = Arc::new(LiquidSdk {
             config: config.clone(),
             onchain_wallet,
@@ -221,6 +233,7 @@ impl LiquidSdk {
             shutdown_receiver,
             send_swap_handler,
             receive_swap_handler,
+            sync_service,
             chain_swap_handler,
             buy_bitcoin_service,
         });
@@ -278,6 +291,14 @@ impl LiquidSdk {
             .clone()
             .start(self.shutdown_receiver.clone())
             .await;
+        if let Err(err) = self
+            .sync_service
+            .clone()
+            .run(self.shutdown_receiver.clone())
+            .await
+        {
+            info!("Could not connect to real-time sync service: {err:?}");
+        }
         self.track_swap_updates().await;
         self.track_pending_swaps().await;
 

lib/core/src/sync/mod.rs

@@ -48,7 +48,7 @@ impl SyncService {
             .persister
             .get_sync_settings()?
             .remote_url
-            .is_some_and(|url| &url == &self.remote_url)
+            .is_some_and(|url| url == self.remote_url)
         {
             true => Ok(()),
             false => self.persister.set_new_remote(self.remote_url.clone()),

lib/core/src/sync/model/sync.rs

@@ -80,10 +80,10 @@ pub mod syncer_client {
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value,
+        clippy::let_unit_value
     )]
-    use tonic::codegen::*;
     use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
     #[derive(Debug, Clone)]
     pub struct SyncerClient<T> {
         inner: tonic::client::Grpc<T>,
@@ -127,9 +127,8 @@ pub mod syncer_client {
                     <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                 >,
             >,
-            <T as tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + std::marker::Send + std::marker::Sync,
         {
             SyncerClient::new(InterceptedService::new(inner, interceptor))
         }
@@ -168,39 +167,28 @@ pub mod syncer_client {
             &mut self,
             request: impl tonic::IntoRequest<super::SetRecordRequest>,
         ) -> std::result::Result<tonic::Response<super::SetRecordReply>, tonic::Status> {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static("/sync.Syncer/SetRecord");
             let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new("sync.Syncer", "SetRecord"));
+            req.extensions_mut()
+                .insert(GrpcMethod::new("sync.Syncer", "SetRecord"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn list_changes(
             &mut self,
             request: impl tonic::IntoRequest<super::ListChangesRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::ListChangesReply>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+        ) -> std::result::Result<tonic::Response<super::ListChangesReply>, tonic::Status> {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static("/sync.Syncer/ListChanges");
             let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new("sync.Syncer", "ListChanges"));
+            req.extensions_mut()
+                .insert(GrpcMethod::new("sync.Syncer", "ListChanges"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn track_changes(
@@ -210,18 +198,14 @@ pub mod syncer_client {
             tonic::Response<tonic::codec::Streaming<super::Record>>,
             tonic::Status,
         > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
+            })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static("/sync.Syncer/TrackChanges");
             let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new("sync.Syncer", "TrackChanges"));
+            req.extensions_mut()
+                .insert(GrpcMethod::new("sync.Syncer", "TrackChanges"));
             self.inner.server_streaming(req, path, codec).await
         }
     }

lib/core/src/test_utils/sdk.rs

@@ -4,7 +4,7 @@ use anyhow::{anyhow, Result};
 use sdk_common::prelude::{BreezServer, STAGING_BREEZSERVER_URL};
 use std::sync::Arc;
 
-use tokio::sync::{watch, Mutex, RwLock};
+use tokio::sync::{mpsc, watch, Mutex, RwLock};
 
 use crate::{
     buy::BuyBitcoinService,
@@ -15,12 +15,14 @@ use crate::{
     receive_swap::ReceiveSwapHandler,
     sdk::LiquidSdk,
     send_swap::SendSwapHandler,
+    sync::{model::sync::Record, SyncService},
 };
 
 use super::{
     chain::{MockBitcoinChainService, MockLiquidChainService},
     status_stream::MockStatusStream,
     swapper::MockSwapper,
+    sync::MockSyncerClient,
     wallet::{MockSigner, MockWallet},
 };
 
@@ -91,6 +93,15 @@ pub(crate) fn new_liquid_sdk_with_chain_services(
     let buy_bitcoin_service =
         Arc::new(BuyBitcoinService::new(config.clone(), breez_server.clone()));
 
+    let (_, incoming_rx) = mpsc::channel::<Record>(10);
+    let syncer_client = Box::new(MockSyncerClient::new(incoming_rx, Default::default()));
+    let sync_service = Arc::new(SyncService::new(
+        "".to_string(),
+        persister.clone(),
+        signer.clone(),
+        syncer_client,
+    ));
+
     Ok(LiquidSdk {
         config,
         onchain_wallet,
@@ -107,6 +118,7 @@ pub(crate) fn new_liquid_sdk_with_chain_services(
         shutdown_receiver,
         send_swap_handler,
         receive_swap_handler,
+        sync_service,
         chain_swap_handler,
         buy_bitcoin_service,
     })

packages/dart/lib/src/frb_generated.dart

@@ -1646,7 +1646,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
   Config dco_decode_config(dynamic raw) {
     // Codec=Dco (DartCObject based), see doc to use other codecs
     final arr = raw as List<dynamic>;
-    if (arr.length != 9) throw Exception('unexpected arr length: expect 9 but see ${arr.length}');
+    if (arr.length != 10) throw Exception('unexpected arr length: expect 10 but see ${arr.length}');
     return Config(
       liquidElectrumUrl: dco_decode_String(arr[0]),
       bitcoinElectrumUrl: dco_decode_String(arr[1]),
@@ -1655,8 +1655,9 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
       network: dco_decode_liquid_network(arr[4]),
       paymentTimeoutSec: dco_decode_u_64(arr[5]),
       zeroConfMinFeeRateMsat: dco_decode_u_32(arr[6]),
-      zeroConfMaxAmountSat: dco_decode_opt_box_autoadd_u_64(arr[7]),
-      breezApiKey: dco_decode_opt_String(arr[8]),
+      syncServiceUrl: dco_decode_String(arr[7]),
+      zeroConfMaxAmountSat: dco_decode_opt_box_autoadd_u_64(arr[8]),
+      breezApiKey: dco_decode_opt_String(arr[9]),
     );
   }
 
@@ -3425,6 +3426,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
     var var_network = sse_decode_liquid_network(deserializer);
     var var_paymentTimeoutSec = sse_decode_u_64(deserializer);
     var var_zeroConfMinFeeRateMsat = sse_decode_u_32(deserializer);
+    var var_syncServiceUrl = sse_decode_String(deserializer);
     var var_zeroConfMaxAmountSat = sse_decode_opt_box_autoadd_u_64(deserializer);
     var var_breezApiKey = sse_decode_opt_String(deserializer);
     return Config(
@@ -3435,6 +3437,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
         network: var_network,
         paymentTimeoutSec: var_paymentTimeoutSec,
         zeroConfMinFeeRateMsat: var_zeroConfMinFeeRateMsat,
+        syncServiceUrl: var_syncServiceUrl,
         zeroConfMaxAmountSat: var_zeroConfMaxAmountSat,
         breezApiKey: var_breezApiKey);
   }
@@ -5323,6 +5326,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
     sse_encode_liquid_network(self.network, serializer);
     sse_encode_u_64(self.paymentTimeoutSec, serializer);
     sse_encode_u_32(self.zeroConfMinFeeRateMsat, serializer);
+    sse_encode_String(self.syncServiceUrl, serializer);
     sse_encode_opt_box_autoadd_u_64(self.zeroConfMaxAmountSat, serializer);
     sse_encode_opt_String(self.breezApiKey, serializer);
   }

packages/dart/lib/src/frb_generated.io.dart

@@ -1997,6 +1997,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl<RustLibWire> {
     wireObj.network = cst_encode_liquid_network(apiObj.network);
     wireObj.payment_timeout_sec = cst_encode_u_64(apiObj.paymentTimeoutSec);
     wireObj.zero_conf_min_fee_rate_msat = cst_encode_u_32(apiObj.zeroConfMinFeeRateMsat);
+    wireObj.sync_service_url = cst_encode_String(apiObj.syncServiceUrl);
     wireObj.zero_conf_max_amount_sat = cst_encode_opt_box_autoadd_u_64(apiObj.zeroConfMaxAmountSat);
     wireObj.breez_api_key = cst_encode_opt_String(apiObj.breezApiKey);
   }
@@ -5574,6 +5575,8 @@ final class wire_cst_config extends ffi.Struct {
   @ffi.Uint32()
   external int zero_conf_min_fee_rate_msat;
 
+  external ffi.Pointer<wire_cst_list_prim_u_8_strict> sync_service_url;
+
   external ffi.Pointer<ffi.Uint64> zero_conf_max_amount_sat;
 
   external ffi.Pointer<wire_cst_list_prim_u_8_strict> breez_api_key;