Merge pull request #885 from h4sh3d/refactor/temp-safety-refactor-2

Refactor: complete temp safety renaming and cleaning

Author: sedited

src/swapd/runtime.rs

@@ -10,6 +10,7 @@ use super::{
     temporal_safety::TemporalSafety,
     StateReport,
 };
+use crate::swapd::temporal_safety::SWEEP_MONERO_THRESHOLD;
 use crate::swapd::Opts;
 use crate::syncerd::bitcoin_syncer::p2wpkh_signed_tx_fee;
 use crate::syncerd::types::{Event, TransactionConfirmations};
@@ -86,10 +87,9 @@ pub fn run(config: ServiceConfig, opts: Opts) -> Result<(), Error> {
     let temporal_safety = TemporalSafety {
         cancel_timelock: cancel_timelock.as_u32(),
         punish_timelock: punish_timelock.as_u32(),
-        btc_finality_thr: arbitrating_finality.into(),
-        race_thr: arbitrating_safety.into(),
-        xmr_finality_thr: accordant_finality.into(),
-        sweep_monero_thr: crate::swapd::temporal_safety::SWEEP_MONERO_THRESHOLD,
+        arb_finality: arbitrating_finality.into(),
+        safety: arbitrating_safety.into(),
+        acc_finality: accordant_finality.into(),
     };
 
     temporal_safety.valid_params()?;
@@ -540,7 +540,7 @@ impl Runtime {
                             id,
                             confirmations,
                             self.swap_id(),
-                            self.temporal_safety.xmr_finality_thr,
+                            self.temporal_safety.acc_finality,
                             endpoints,
                         );
 
@@ -608,7 +608,7 @@ impl Runtime {
                             id,
                             &Some(*confirmations),
                             self.swap_id(),
-                            self.temporal_safety.btc_finality_thr,
+                            self.temporal_safety.arb_finality,
                             endpoints,
                         );
                         // saving requests of interest for later replaying latest event
@@ -628,7 +628,7 @@ impl Runtime {
                             id,
                             confirmations,
                             self.swap_id(),
-                            self.temporal_safety.btc_finality_thr,
+                            self.temporal_safety.arb_finality,
                             endpoints,
                         );
                         // saving requests of interest for later replaying latest event
@@ -848,8 +848,8 @@ impl Runtime {
         let acc_confs_needs = self
             .syncer_state
             .get_confs(TxLabel::AccLock)
-            .map(|confs| self.temporal_safety.sweep_monero_thr.saturating_sub(confs))
-            .unwrap_or(self.temporal_safety.sweep_monero_thr);
+            .map(|confs| SWEEP_MONERO_THRESHOLD.saturating_sub(confs))
+            .unwrap_or(SWEEP_MONERO_THRESHOLD);
         let sweep_block = self.syncer_state.height(Blockchain::Monero) + acc_confs_needs as u64;
         self.log_info(format!(
             "Tx {} needs {} more confirmations to spending maturity, and has {} confirmations.\n\

src/swapd/state_report.rs

@@ -8,6 +8,7 @@ use farcaster_core::{blockchain::Blockchain, transaction::TxLabel};
 use strict_encoding::{NetworkDecode, NetworkEncode};
 
 use crate::bus::{Progress, StateTransition};
+use crate::swapd::temporal_safety::SWEEP_MONERO_THRESHOLD;
 
 use super::{syncer_client::SyncerState, temporal_safety::TemporalSafety};
 
@@ -70,13 +71,13 @@ impl StateReport {
                 .map(|confs| temp_safety.blocks_until_cancel(confs)),
             blocks_until_safe_buy: syncer_state
                 .get_confs(TxLabel::Lock)
-                .map(|c| temp_safety.btc_finality_thr.saturating_sub(c)),
+                .map(|c| temp_safety.arb_finality.saturating_sub(c)),
             blocks_until_punish_possible: syncer_state
                 .get_confs(TxLabel::Cancel)
                 .map(|confs| temp_safety.blocks_until_punish_after_cancel(confs)),
             blocks_until_safe_monero_buy_sweep: syncer_state
                 .get_confs(TxLabel::AccLock)
-                .map(|c| temp_safety.sweep_monero_thr.saturating_sub(c)),
+                .map(|c| SWEEP_MONERO_THRESHOLD.saturating_sub(c)),
         }
     }
 

src/swapd/swap_state.rs

@@ -22,6 +22,7 @@ use microservices::esb::Handler;
 use monero::ViewPair;
 use strict_encoding::{StrictDecode, StrictEncode};
 
+use crate::swapd::temporal_safety::SWEEP_MONERO_THRESHOLD;
 use crate::{
     bus::{ctl::MoneroFundingInfo, p2p::Reveal},
     syncerd::AddressTransaction,
@@ -1325,7 +1326,7 @@ fn try_bob_buy_seen_to_bob_buy_sweeping(
                 confirmations: Some(confirmations),
                 ..
             },
-        ))) if confirmations >= runtime.temporal_safety.sweep_monero_thr => {
+        ))) if confirmations >= SWEEP_MONERO_THRESHOLD => {
             // safe cast
             let request = SyncMsg::Task(Task::SweepAddress(task));
             runtime.log_info(format!(
@@ -2119,7 +2120,7 @@ fn try_alice_refund_to_alice_refund_sweeping(
                 confirmations: Some(confirmations),
                 ..
             },
-        ))) if confirmations >= runtime.temporal_safety.sweep_monero_thr => {
+        ))) if confirmations >= SWEEP_MONERO_THRESHOLD => {
             runtime.log_info(format!(
                 "Monero are spendable now (height {}), sweeping ephemeral swap_key_manager",
                 runtime.syncer_state.monero_height.label(),

src/swapd/temporal_safety.rs

@@ -27,29 +27,23 @@ pub struct TemporalSafety {
     /// Second timelock in the protocol, if this timelock is reached Bob miss-behaved and will lose
     /// money
     pub punish_timelock: BlockHeight,
-    /// The minimum number of blocks that should remain unmined before the next transaction to be
-    /// considered safe
-    pub race_thr: BlockSpan,
+    /// Avoid broadcasting a transaction if a race can happen with the next available execution
+    /// fork in # blocks
+    pub safety: BlockSpan,
     /// Number of confirmation required for the arbitrating blockchain to consider a tx final
-    pub btc_finality_thr: BlockSpan,
+    pub arb_finality: BlockSpan,
     /// Number of confirmation required for the accordant blockchain to consider a tx final
-    pub xmr_finality_thr: BlockSpan,
-    // FIXME: this should be removed, used only const instead
-    pub sweep_monero_thr: BlockSpan,
+    pub acc_finality: BlockSpan,
 }
 
 impl TemporalSafety {
     /// Validate if temporal parameters are coherent
     pub fn valid_params(&self) -> Result<(), Error> {
-        let btc_finality = self.btc_finality_thr;
+        let finality = self.arb_finality;
         let cancel = self.cancel_timelock;
         let punish = self.punish_timelock;
-        let race = self.race_thr;
-        if btc_finality < cancel
-            && cancel < punish
-            && btc_finality < race
-            && punish > race
-            && cancel > race
+        let race = self.safety;
+        if finality < cancel && cancel < punish && finality < race && punish > race && cancel > race
         {
             Ok(())
         } else {
@@ -61,23 +55,23 @@ impl TemporalSafety {
 
     /// Returns whether tx is final given the finality threshold set for the chain
     pub fn final_tx(&self, confs: u32, blockchain: Blockchain) -> bool {
-        let finality_thr = match blockchain {
-            Blockchain::Bitcoin => self.btc_finality_thr,
-            Blockchain::Monero => self.xmr_finality_thr,
+        let finality = match blockchain {
+            Blockchain::Bitcoin => self.arb_finality,
+            Blockchain::Monero => self.acc_finality,
         };
-        confs >= finality_thr
+        confs >= finality
     }
 
     /// Lock must be final, cancel cannot be raced, add + 1 to offset initial lock confirmation
     pub fn stop_funding_before_cancel(&self, lock_confirmations: u32) -> bool {
         self.final_tx(lock_confirmations, Blockchain::Bitcoin)
-            && lock_confirmations > (self.cancel_timelock - self.race_thr + 1)
+            && lock_confirmations > (self.cancel_timelock - self.safety + 1)
     }
 
     // Blocks remaining until funding will be stopped for safety, because it is too close to
     // cancel. Adds the same +1 offset as in stop_funding_before_cancel
     pub fn blocks_until_stop_funding(&self, lock_confirmations: u32) -> i64 {
-        self.cancel_timelock as i64 - (self.race_thr as i64 + 1 + lock_confirmations as i64)
+        self.cancel_timelock as i64 - (self.safety as i64 + 1 + lock_confirmations as i64)
     }
 
     /// Lock must be final, valid after lock_minedblock + cancel_timelock
@@ -94,13 +88,13 @@ impl TemporalSafety {
     /// Lock must be final, but buy shall not be raced with cancel
     pub fn safe_buy(&self, lock_confirmations: u32) -> bool {
         self.final_tx(lock_confirmations, Blockchain::Bitcoin)
-            && lock_confirmations <= (self.cancel_timelock - self.race_thr)
+            && lock_confirmations <= (self.cancel_timelock - self.safety)
     }
 
     /// Cancel must be final, but refund shall not be raced with punish
     pub fn safe_refund(&self, cancel_confirmations: u32) -> bool {
         self.final_tx(cancel_confirmations, Blockchain::Bitcoin)
-            && cancel_confirmations <= (self.punish_timelock - self.race_thr)
+            && cancel_confirmations <= (self.punish_timelock - self.safety)
     }
 
     /// Cancel must be final, valid after cancel_confirmations > punish_timelock