fix(legacy-refunds): support going the spending path on refund

mm2src/mm2_main/src/lp_swap.rs

@@ -87,7 +87,7 @@ use std::convert::TryFrom;
 use std::num::NonZeroUsize;
 use std::path::PathBuf;
 use std::str::FromStr;
-use std::sync::{Arc, Mutex, Weak};
+use std::sync::{Arc, Mutex};
 use std::time::Duration;
 use uuid::Uuid;
 
@@ -475,6 +475,22 @@ pub struct RecoveredSwap {
     transaction: TransactionEnum,
 }
 
+#[derive(Display, Debug, PartialEq)]
+pub enum RecoverSwapError {
+    // We might not find the original payment tx on chain (e.g. re-orged). This doesn't mean though that nobody has it.
+    // TODO: These coins should be spent ASAP to avoid them getting locked (or stolen).
+    #[display(fmt = "The payment tx is not on-chain. Nothing to recover.")]
+    PaymentTxNotFound,
+    #[display(fmt = "An unknown error occurred. Retrying might fix it: {}", _0)]
+    Temporary(String),
+    #[display(fmt = "The swap is not recoverable: {}", _0)]
+    Irrecoverable(String),
+    #[display(fmt = "Wait {}s and try to recover again.", _0)]
+    WaitAndRetry(u64),
+    #[display(fmt = "The funds will be automatically recovered after lock-time: {}", _0)]
+    AutoRecoverableAfter(u64),
+}
+
 /// Represents the amount of a coin locked by ongoing swap
 #[derive(Debug)]
 pub struct LockedAmount {
@@ -515,8 +531,11 @@ struct LockedAmountInfo {
     locked_amount: LockedAmount,
 }
 
+/// A running swap is the swap accompanied by the abort handle of the thread the swap is running on.
+type RunningSwap = (Arc<dyn AtomicSwap>, AbortOnDropHandle);
+
 struct SwapsContext {
-    running_swaps: Mutex<Vec<Weak<dyn AtomicSwap>>>,
+    running_swaps: Mutex<HashMap<Uuid, RunningSwap>>,
     active_swaps_v2_infos: Mutex<HashMap<Uuid, ActiveSwapV2Info>>,
     banned_pubkeys: Mutex<HashMap<H256Json, BanReason>>,
     swap_msgs: Mutex<HashMap<Uuid, SwapMsgStore>>,
@@ -532,7 +551,7 @@ impl SwapsContext {
     fn from_ctx(ctx: &MmArc) -> Result<Arc<SwapsContext>, String> {
         Ok(try_s!(from_ctx(&ctx.swaps_ctx, move || {
             Ok(SwapsContext {
-                running_swaps: Mutex::new(vec![]),
+                running_swaps: Mutex::new(HashMap::new()),
                 active_swaps_v2_infos: Mutex::new(HashMap::new()),
                 banned_pubkeys: Mutex::new(HashMap::new()),
                 swap_msgs: Mutex::new(HashMap::new()),
@@ -617,11 +636,9 @@ pub fn get_locked_amount(ctx: &MmArc, coin: &str) -> MmNumber {
     let swap_ctx = SwapsContext::from_ctx(ctx).unwrap();
     let swap_lock = swap_ctx.running_swaps.lock().unwrap();
 
-    let mut locked = swap_lock
-        .iter()
-        .filter_map(|swap| swap.upgrade())
-        .flat_map(|swap| swap.locked_amount())
-        .fold(MmNumber::from(0), |mut total_amount, locked| {
+    let mut locked = swap_lock.values().flat_map(|(swap, _)| swap.locked_amount()).fold(
+        MmNumber::from(0),
+        |mut total_amount, locked| {
             if locked.coin == coin {
                 total_amount += locked.amount;
             }
@@ -631,7 +648,8 @@ pub fn get_locked_amount(ctx: &MmArc, coin: &str) -> MmNumber {
                 }
             }
             total_amount
-        });
+        },
+    );
     drop(swap_lock);
 
     let locked_amounts = swap_ctx.locked_amounts.lock().unwrap();
@@ -655,11 +673,8 @@ pub fn get_locked_amount(ctx: &MmArc, coin: &str) -> MmNumber {
 /// Get number of currently running swaps
 pub fn running_swaps_num(ctx: &MmArc) -> u64 {
     let swap_ctx = SwapsContext::from_ctx(ctx).unwrap();
-    let swaps = swap_ctx.running_swaps.lock().unwrap();
-    swaps.iter().fold(0, |total, swap| match swap.upgrade() {
-        Some(_) => total + 1,
-        None => total,
-    })
+    let count = swap_ctx.running_swaps.lock().unwrap().len();
+    count as u64
 }
 
 /// Get total amount of selected coin locked by all currently ongoing swaps except the one with selected uuid
@@ -668,10 +683,9 @@ fn get_locked_amount_by_other_swaps(ctx: &MmArc, except_uuid: &Uuid, coin: &str)
     let swap_lock = swap_ctx.running_swaps.lock().unwrap();
 
     swap_lock
-        .iter()
-        .filter_map(|swap| swap.upgrade())
-        .filter(|swap| swap.uuid() != except_uuid)
-        .flat_map(|swap| swap.locked_amount())
+        .values()
+        .filter(|(swap, _)| swap.uuid() != except_uuid)
+        .flat_map(|(swap, _)| swap.locked_amount())
         .fold(MmNumber::from(0), |mut total_amount, locked| {
             if locked.coin == coin {
                 total_amount += locked.amount;
@@ -689,11 +703,9 @@ pub fn active_swaps_using_coins(ctx: &MmArc, coins: &HashSet<String>) -> Result<
     let swap_ctx = try_s!(SwapsContext::from_ctx(ctx));
     let swaps = try_s!(swap_ctx.running_swaps.lock());
     let mut uuids = vec![];
-    for swap in swaps.iter() {
-        if let Some(swap) = swap.upgrade() {
-            if coins.contains(&swap.maker_coin().to_string()) || coins.contains(&swap.taker_coin().to_string()) {
-                uuids.push(*swap.uuid())
-            }
+    for (swap, _) in swaps.values() {
+        if coins.contains(&swap.maker_coin().to_string()) || coins.contains(&swap.taker_coin().to_string()) {
+            uuids.push(*swap.uuid())
         }
     }
     drop(swaps);
@@ -709,15 +721,13 @@ pub fn active_swaps_using_coins(ctx: &MmArc, coins: &HashSet<String>) -> Result<
 
 pub fn active_swaps(ctx: &MmArc) -> Result<Vec<(Uuid, u8)>, String> {
     let swap_ctx = try_s!(SwapsContext::from_ctx(ctx));
-    let swaps = swap_ctx.running_swaps.lock().unwrap();
-    let mut uuids = vec![];
-    for swap in swaps.iter() {
-        if let Some(swap) = swap.upgrade() {
-            uuids.push((*swap.uuid(), LEGACY_SWAP_TYPE))
-        }
-    }
-
-    drop(swaps);
+    let mut uuids: Vec<_> = swap_ctx
+        .running_swaps
+        .lock()
+        .unwrap()
+        .keys()
+        .map(|uuid| (*uuid, LEGACY_SWAP_TYPE))
+        .collect();
 
     let swaps_v2 = swap_ctx.active_swaps_v2_infos.lock().unwrap();
     uuids.extend(swaps_v2.iter().map(|(uuid, info)| (*uuid, info.swap_type)));