Verify and claim swap if not verifiable in swap loop (#681)

* Verify and claim swap if not verifiable in swap loop

* Verify lockup amount

* Tolerate overpayment

* Adapt receive swap test

* Separate verification functions and set swap Failed if underpaid

Author: dangeross

.gitignore

@@ -9,6 +9,7 @@ packages/flutter/ios/Classes/breez_sdk_liquidFFI.h
 packages/flutter/macos/Classes/breez_sdk_liquidFFI.h
 # Miscellaneous
 .DS_Store
+*.sln
 .idea/
 
 **/target

lib/core/src/chain_swap.rs

@@ -1549,6 +1549,7 @@ mod tests {
                     None,
                     false,
                     false,
+                    None,
                 );
                 persister.insert_or_update_chain_swap(&chain_swap)?;
 
@@ -1582,6 +1583,7 @@ mod tests {
                     None,
                     false,
                     false,
+                    None,
                 );
                 persister.insert_or_update_chain_swap(&chain_swap)?;
 

lib/core/src/persist/backup.rs

@@ -47,8 +47,9 @@ mod tests {
     fn test_backup_and_restore() -> Result<()> {
         create_persister!(local);
 
-        local.insert_or_update_send_swap(&new_send_swap(Some(PaymentState::Pending)))?;
-        local.insert_or_update_receive_swap(&new_receive_swap(Some(PaymentState::Pending)))?;
+        local.insert_or_update_send_swap(&new_send_swap(Some(PaymentState::Pending), None))?;
+        local
+            .insert_or_update_receive_swap(&new_receive_swap(Some(PaymentState::Pending), None))?;
         assert_eq!(local.list_ongoing_swaps()?.len(), 2);
 
         let backup_path = local.get_default_backup_path();

lib/core/src/persist/chain.rs

@@ -548,7 +548,7 @@ mod tests {
     async fn test_writing_stale_swap() -> Result<()> {
         create_persister!(storage);
 
-        let chain_swap = new_chain_swap(Direction::Incoming, None, false, None, false, false);
+        let chain_swap = new_chain_swap(Direction::Incoming, None, false, None, false, false, None);
         storage.insert_or_update_chain_swap(&chain_swap)?;
 
         // read - update - write works if there are no updates in between
@@ -575,7 +575,7 @@ mod tests {
         create_persister!(storage);
 
         let chain_swap_local_with_sync_state =
-            new_chain_swap(Direction::Incoming, None, false, None, false, false);
+            new_chain_swap(Direction::Incoming, None, false, None, false, false, None);
         storage.insert_or_update_chain_swap(&chain_swap_local_with_sync_state)?;
         storage.set_sync_state(SyncState {
             data_id: chain_swap_local_with_sync_state.id.clone(),
@@ -585,11 +585,11 @@ mod tests {
         })?;
 
         let chain_swap_local_no_sync_state =
-            new_chain_swap(Direction::Incoming, None, false, None, false, false);
+            new_chain_swap(Direction::Incoming, None, false, None, false, false, None);
         storage.insert_or_update_chain_swap(&chain_swap_local_no_sync_state)?;
 
         let chain_swap_not_local =
-            new_chain_swap(Direction::Incoming, None, false, None, false, false);
+            new_chain_swap(Direction::Incoming, None, false, None, false, false, None);
         storage.insert_or_update_chain_swap(&chain_swap_not_local)?;
         storage.set_sync_state(SyncState {
             data_id: chain_swap_not_local.id,

lib/core/src/persist/mod.rs

@@ -357,7 +357,7 @@ impl Persister {
             .map(Swap::Send)
             .collect();
         let ongoing_receive_swaps: Vec<Swap> = self
-            .list_ongoing_receive_swaps()?
+            .list_ongoing_receive_swaps(None)?
             .into_iter()
             .map(Swap::Receive)
             .collect();
@@ -1022,8 +1022,9 @@ mod tests {
     fn test_list_ongoing_swaps() -> Result<()> {
         create_persister!(storage);
 
-        storage.insert_or_update_send_swap(&new_send_swap(None))?;
-        storage.insert_or_update_receive_swap(&new_receive_swap(Some(PaymentState::Pending)))?;
+        storage.insert_or_update_send_swap(&new_send_swap(None, None))?;
+        storage
+            .insert_or_update_receive_swap(&new_receive_swap(Some(PaymentState::Pending), None))?;
 
         assert_eq!(storage.list_ongoing_swaps()?.len(), 2);
 

lib/core/src/persist/receive.rs

@@ -156,8 +156,12 @@ impl Persister {
                 rs.created_at,
                 rs.state,
                 rs.pair_fees_json,
-                rs.version
+                rs.version,
+
+                -- Used for filtering
+                sync_state.is_local
             FROM receive_swaps AS rs
+            LEFT JOIN sync_state ON rs.id = sync_state.data_id
             {where_clause_str}
             ORDER BY rs.created_at
         "
@@ -222,12 +226,21 @@ impl Persister {
         Ok(ongoing_receive)
     }
 
-    pub(crate) fn list_ongoing_receive_swaps(&self) -> Result<Vec<ReceiveSwap>> {
+    pub(crate) fn list_ongoing_receive_swaps(
+        &self,
+        is_local: Option<bool>,
+    ) -> Result<Vec<ReceiveSwap>> {
         let con = self.get_connection()?;
-        let where_clause = vec![get_where_clause_state_in(&[
+        let mut where_clause = vec![get_where_clause_state_in(&[
             PaymentState::Created,
             PaymentState::Pending,
         ])];
+        if let Some(is_local) = is_local {
+            where_clause.push(format!(
+                "(sync_state.is_local = {} OR sync_state.is_local IS NULL)",
+                is_local as i8
+            ));
+        }
 
         self.list_receive_swaps_where(&con, where_clause)
     }
@@ -397,7 +410,7 @@ mod tests {
     fn test_fetch_receive_swap() -> Result<()> {
         create_persister!(storage);
 
-        let receive_swap = new_receive_swap(None);
+        let receive_swap = new_receive_swap(None, None);
 
         storage.insert_or_update_receive_swap(&receive_swap)?;
         // Fetch swap by id
@@ -417,16 +430,17 @@ mod tests {
         // List general receive swaps
         let range = 0..3;
         for _ in range.clone() {
-            storage.insert_or_update_receive_swap(&new_receive_swap(None))?;
+            storage.insert_or_update_receive_swap(&new_receive_swap(None, None))?;
         }
 
         let con = storage.get_connection()?;
         let swaps = storage.list_receive_swaps_where(&con, vec![])?;
         assert_eq!(swaps.len(), range.len());
 
         // List ongoing receive swaps
-        storage.insert_or_update_receive_swap(&new_receive_swap(Some(PaymentState::Pending)))?;
-        let ongoing_swaps = storage.list_ongoing_receive_swaps()?;
+        storage
+            .insert_or_update_receive_swap(&new_receive_swap(Some(PaymentState::Pending), None))?;
+        let ongoing_swaps = storage.list_ongoing_receive_swaps(None)?;
         assert_eq!(ongoing_swaps.len(), 4);
 
         Ok(())
@@ -436,7 +450,7 @@ mod tests {
     fn test_update_receive_swap() -> Result<()> {
         create_persister!(storage);
 
-        let receive_swap = new_receive_swap(None);
+        let receive_swap = new_receive_swap(None, None);
         storage.insert_or_update_receive_swap(&receive_swap)?;
 
         // Update metadata
@@ -466,7 +480,7 @@ mod tests {
     async fn test_writing_stale_swap() -> Result<()> {
         create_persister!(storage);
 
-        let receive_swap = new_receive_swap(None);
+        let receive_swap = new_receive_swap(None, None);
         storage.insert_or_update_receive_swap(&receive_swap)?;
 
         // read - update - write works if there are no updates in between

lib/core/src/persist/send.rs

@@ -400,7 +400,7 @@ mod tests {
     #[test]
     fn test_fetch_send_swap() -> Result<()> {
         create_persister!(storage);
-        let send_swap = new_send_swap(None);
+        let send_swap = new_send_swap(None, None);
 
         storage.insert_or_update_send_swap(&send_swap)?;
         // Fetch swap by id
@@ -420,15 +420,15 @@ mod tests {
         // List general send swaps
         let range = 0..3;
         for _ in range.clone() {
-            storage.insert_or_update_send_swap(&new_send_swap(None))?;
+            storage.insert_or_update_send_swap(&new_send_swap(None, None))?;
         }
 
         let con = storage.get_connection()?;
         let swaps = storage.list_send_swaps_where(&con, vec![])?;
         assert_eq!(swaps.len(), range.len());
 
         // List ongoing send swaps
-        storage.insert_or_update_send_swap(&new_send_swap(Some(PaymentState::Pending)))?;
+        storage.insert_or_update_send_swap(&new_send_swap(Some(PaymentState::Pending), None))?;
         let ongoing_swaps = storage.list_ongoing_send_swaps()?;
         assert_eq!(ongoing_swaps.len(), 4);
 
@@ -443,7 +443,7 @@ mod tests {
     fn test_update_send_swap() -> Result<()> {
         create_persister!(storage);
 
-        let mut send_swap = new_send_swap(None);
+        let mut send_swap = new_send_swap(None, None);
         storage.insert_or_update_send_swap(&send_swap)?;
 
         // Update metadata
@@ -486,7 +486,7 @@ mod tests {
     async fn test_writing_stale_swap() -> Result<()> {
         create_persister!(storage);
 
-        let send_swap = new_send_swap(None);
+        let send_swap = new_send_swap(None, None);
         storage.insert_or_update_send_swap(&send_swap)?;
 
         // read - update - write works if there are no updates in between