fix: pre-check updated fields before committing for real-time sync (#623)

---------
Co-authored-by: yse <hydra_yse@proton.me>

Author: dangeross

lib/core/src/persist/chain.rs

@@ -8,6 +8,7 @@ use crate::ensure_sdk;
 use crate::error::PaymentError;
 use crate::model::*;
 use crate::persist::{get_where_clause_state_in, Persister};
+use crate::sync::model::data::ChainSyncData;
 use crate::sync::model::RecordType;
 
 impl Persister {
@@ -62,8 +63,6 @@ impl Persister {
             "UPDATE chain_swaps
             SET
                 description = :description,
-                payer_amount_sat = :payer_amount_sat,
-                receiver_amount_sat = :receiver_amount_sat,
                 accept_zero_conf = :accept_zero_conf,
                 server_lockup_tx_id = :server_lockup_tx_id,
                 user_lockup_tx_id = :user_lockup_tx_id,
@@ -77,8 +76,6 @@ impl Persister {
             named_params! {
                 ":id": &chain_swap.id,
                 ":description": &chain_swap.description,
-                ":payer_amount_sat": &chain_swap.payer_amount_sat,
-                ":receiver_amount_sat": &chain_swap.receiver_amount_sat,
                 ":accept_zero_conf": &chain_swap.accept_zero_conf,
                 ":server_lockup_tx_id": &chain_swap.server_lockup_tx_id,
                 ":user_lockup_tx_id": &chain_swap.user_lockup_tx_id,
@@ -94,13 +91,28 @@ impl Persister {
     }
 
     pub(crate) fn insert_or_update_chain_swap(&self, chain_swap: &ChainSwap) -> Result<()> {
+        let maybe_swap = self.fetch_chain_swap_by_id(&chain_swap.id)?;
+        let updated_fields = ChainSyncData::updated_fields(maybe_swap, chain_swap);
+
         let mut con = self.get_connection()?;
         let tx = con.transaction_with_behavior(TransactionBehavior::Immediate)?;
 
         Self::insert_or_update_chain_swap_inner(&tx, chain_swap)?;
-        self.commit_outgoing(&tx, &chain_swap.id, RecordType::Chain, None)?;
-        tx.commit()?;
-        self.sync_trigger.try_send(())?;
+
+        // Trigger a sync if:
+        // - updated_fields is None (swap is inserted, not updated)
+        // - updated_fields in a non empty list of updated fields
+        let trigger_sync = updated_fields.as_ref().map_or(true, |u| !u.is_empty());
+        match trigger_sync {
+            true => {
+                self.commit_outgoing(&tx, &chain_swap.id, RecordType::Chain, updated_fields)?;
+                tx.commit()?;
+                self.sync_trigger.try_send(())?;
+            }
+            false => {
+                tx.commit()?;
+            }
+        };
 
         Ok(())
     }

lib/core/src/persist/receive.rs

@@ -8,6 +8,7 @@ use crate::ensure_sdk;
 use crate::error::PaymentError;
 use crate::model::*;
 use crate::persist::{get_where_clause_state_in, Persister};
+use crate::sync::model::data::ReceiveSyncData;
 use crate::sync::model::RecordType;
 
 impl Persister {
@@ -83,13 +84,28 @@ impl Persister {
     }
 
     pub(crate) fn insert_or_update_receive_swap(&self, receive_swap: &ReceiveSwap) -> Result<()> {
+        let maybe_swap = self.fetch_receive_swap_by_id(&receive_swap.id)?;
+        let updated_fields = ReceiveSyncData::updated_fields(maybe_swap, receive_swap);
+
         let mut con = self.get_connection()?;
         let tx = con.transaction_with_behavior(TransactionBehavior::Immediate)?;
 
         Self::insert_or_update_receive_swap_inner(&tx, receive_swap)?;
-        self.commit_outgoing(&tx, &receive_swap.id, RecordType::Receive, None)?;
-        tx.commit()?;
-        self.sync_trigger.try_send(())?;
+
+        // Trigger a sync if:
+        // - updated_fields is None (swap is inserted, not updated)
+        // - updated_fields in a non empty list of updated fields
+        let trigger_sync = updated_fields.as_ref().map_or(true, |u| !u.is_empty());
+        match trigger_sync {
+            true => {
+                self.commit_outgoing(&tx, &receive_swap.id, RecordType::Receive, updated_fields)?;
+                tx.commit()?;
+                self.sync_trigger.try_send(())?;
+            }
+            false => {
+                tx.commit()?;
+            }
+        };
 
         Ok(())
     }

lib/core/src/persist/send.rs

@@ -7,6 +7,7 @@ use serde::{Deserialize, Serialize};
 use crate::error::PaymentError;
 use crate::model::*;
 use crate::persist::{get_where_clause_state_in, Persister};
+use crate::sync::model::data::SendSyncData;
 use crate::sync::model::RecordType;
 use crate::{ensure_sdk, get_updated_fields};
 
@@ -75,13 +76,28 @@ impl Persister {
     }
 
     pub(crate) fn insert_or_update_send_swap(&self, send_swap: &SendSwap) -> Result<()> {
+        let maybe_swap = self.fetch_send_swap_by_id(&send_swap.id)?;
+        let updated_fields = SendSyncData::updated_fields(maybe_swap, send_swap);
+
         let mut con = self.get_connection()?;
         let tx = con.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?;
 
         Self::insert_or_update_send_swap_inner(&tx, send_swap)?;
-        self.commit_outgoing(&tx, &send_swap.id, RecordType::Send, None)?;
-        tx.commit()?;
-        self.sync_trigger.try_send(())?;
+
+        // Trigger a sync if:
+        // - updated_fields is None (swap is inserted, not updated)
+        // - updated_fields in a non empty list of updated fields
+        let trigger_sync = updated_fields.as_ref().map_or(true, |u| !u.is_empty());
+        match trigger_sync {
+            true => {
+                self.commit_outgoing(&tx, &send_swap.id, RecordType::Send, updated_fields)?;
+                tx.commit()?;
+                self.sync_trigger.try_send(())?;
+            }
+            false => {
+                tx.commit()?;
+            }
+        };
 
         Ok(())
     }

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

@@ -30,13 +30,27 @@ impl ChainSyncData {
     pub(crate) fn merge(&mut self, other: &Self, updated_fields: &[String]) {
         for field in updated_fields {
             match field.as_str() {
-                "payer_amount_sat" => self.payer_amount_sat = other.payer_amount_sat,
-                "receiver_amount_sat" => self.receiver_amount_sat = other.receiver_amount_sat,
                 "accept_zero_conf" => self.accept_zero_conf = other.accept_zero_conf,
                 _ => continue,
             }
         }
     }
+
+    pub(crate) fn updated_fields(
+        swap: Option<ChainSwap>,
+        update: &ChainSwap,
+    ) -> Option<Vec<String>> {
+        match swap {
+            Some(swap) => {
+                let mut updated_fields = vec![];
+                if update.accept_zero_conf != swap.accept_zero_conf {
+                    updated_fields.push("accept_zero_conf".to_string());
+                }
+                Some(updated_fields)
+            }
+            None => None,
+        }
+    }
 }
 
 impl From<ChainSwap> for ChainSyncData {
@@ -114,6 +128,19 @@ impl SendSyncData {
             }
         }
     }
+
+    pub(crate) fn updated_fields(swap: Option<SendSwap>, update: &SendSwap) -> Option<Vec<String>> {
+        match swap {
+            Some(swap) => {
+                let mut updated_fields = vec![];
+                if update.preimage.is_some() && update.preimage != swap.preimage {
+                    updated_fields.push("preimage".to_string());
+                }
+                Some(updated_fields)
+            }
+            None => None,
+        }
+    }
 }
 
 impl From<SendSwap> for SendSyncData {
@@ -174,6 +201,21 @@ pub(crate) struct ReceiveSyncData {
     pub(crate) description: Option<String>,
 }
 
+impl ReceiveSyncData {
+    pub(crate) fn updated_fields(
+        swap: Option<ReceiveSwap>,
+        _update: &ReceiveSwap,
+    ) -> Option<Vec<String>> {
+        match swap {
+            Some(_swap) => {
+                let updated_fields = vec![];
+                Some(updated_fields)
+            }
+            None => None,
+        }
+    }
+}
+
 impl From<ReceiveSwap> for ReceiveSyncData {
     fn from(value: ReceiveSwap) -> Self {
         Self {