diff --git a/mm2src/coins/eth.rs b/mm2src/coins/eth.rs
index a6cd170627..5fc048af7a 100644
--- a/mm2src/coins/eth.rs
+++ b/mm2src/coins/eth.rs
@@ -1117,11 +1117,11 @@ impl SwapOps for EthCoin {
         )
     }
 
-    fn send_maker_payment(&self, maker_payment: SendPaymentArgs) -> TransactionFut {
-        Box::new(
-            self.send_hash_time_locked_payment(maker_payment)
-                .map(TransactionEnum::from),
-        )
+    async fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs<'_>) -> TransactionResult {
+        self.send_hash_time_locked_payment(maker_payment_args)
+            .compat()
+            .await
+            .map(TransactionEnum::from)
     }
 
     fn send_taker_payment(&self, taker_payment: SendPaymentArgs) -> TransactionFut {
diff --git a/mm2src/coins/lightning.rs b/mm2src/coins/lightning.rs
index 2feb7ef014..14478a670c 100644
--- a/mm2src/coins/lightning.rs
+++ b/mm2src/coins/lightning.rs
@@ -615,19 +615,15 @@ impl SwapOps for LightningCoin {
         Box::new(fut.boxed().compat())
     }
 
-    fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs<'_>) -> TransactionFut {
+    async fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs<'_>) -> TransactionResult {
         let invoice = match maker_payment_args.payment_instructions.clone() {
             Some(PaymentInstructions::Lightning(invoice)) => invoice,
-            _ => try_tx_fus!(ERR!("Invalid instructions, ligntning invoice is expected")),
+            _ => try_tx_s!(ERR!("Invalid instructions, ligntning invoice is expected")),
         };
 
-        let coin = self.clone();
-        let fut = async move {
-            // No need for max_total_cltv_expiry_delta for lightning maker payment since the maker is the side that reveals the secret/preimage
-            let payment = try_tx_s!(coin.pay_invoice(invoice, None).await);
-            Ok(payment.payment_hash.into())
-        };
-        Box::new(fut.boxed().compat())
+        // No need for max_total_cltv_expiry_delta for lightning maker payment since the maker is the side that reveals the secret/preimage
+        let payment = try_tx_s!(self.pay_invoice(invoice, None).await);
+        Ok(payment.payment_hash.into())
     }
 
     fn send_taker_payment(&self, taker_payment_args: SendPaymentArgs<'_>) -> TransactionFut {
diff --git a/mm2src/coins/lp_coins.rs b/mm2src/coins/lp_coins.rs
index 3e5f55ce41..89740441a7 100644
--- a/mm2src/coins/lp_coins.rs
+++ b/mm2src/coins/lp_coins.rs
@@ -1071,7 +1071,7 @@ pub enum WatcherRewardError {
 pub trait SwapOps {
     fn send_taker_fee(&self, fee_addr: &[u8], dex_fee: DexFee, uuid: &[u8], expire_at: u64) -> TransactionFut;
 
-    fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs<'_>) -> TransactionFut;
+    async fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs<'_>) -> TransactionResult;
 
     fn send_taker_payment(&self, taker_payment_args: SendPaymentArgs<'_>) -> TransactionFut;
 
diff --git a/mm2src/coins/qrc20.rs b/mm2src/coins/qrc20.rs
index b1d250c755..6ffadb1d4e 100644
--- a/mm2src/coins/qrc20.rs
+++ b/mm2src/coins/qrc20.rs
@@ -771,21 +771,16 @@ impl SwapOps for Qrc20Coin {
         Box::new(fut.boxed().compat())
     }
 
-    fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs) -> TransactionFut {
-        let time_lock = try_tx_fus!(maker_payment_args.time_lock.try_into());
-        let taker_addr = try_tx_fus!(self.contract_address_from_raw_pubkey(maker_payment_args.other_pubkey));
+    async fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs<'_>) -> TransactionResult {
+        let time_lock = try_tx_s!(maker_payment_args.time_lock.try_into());
+        let taker_addr = try_tx_s!(self.contract_address_from_raw_pubkey(maker_payment_args.other_pubkey));
         let id = qrc20_swap_id(time_lock, maker_payment_args.secret_hash);
-        let value = try_tx_fus!(wei_from_big_decimal(&maker_payment_args.amount, self.utxo.decimals));
+        let value = try_tx_s!(wei_from_big_decimal(&maker_payment_args.amount, self.utxo.decimals));
         let secret_hash = Vec::from(maker_payment_args.secret_hash);
-        let swap_contract_address = try_tx_fus!(maker_payment_args.swap_contract_address.try_to_address());
+        let swap_contract_address = try_tx_s!(maker_payment_args.swap_contract_address.try_to_address());
 
-        let selfi = self.clone();
-        let fut = async move {
-            selfi
-                .send_hash_time_locked_payment(id, value, time_lock, secret_hash, taker_addr, swap_contract_address)
-                .await
-        };
-        Box::new(fut.boxed().compat())
+        self.send_hash_time_locked_payment(id, value, time_lock, secret_hash, taker_addr, swap_contract_address)
+            .await
     }
 
     #[inline]
diff --git a/mm2src/coins/siacoin.rs b/mm2src/coins/siacoin.rs
index 4e77a74731..84af0346fc 100644
--- a/mm2src/coins/siacoin.rs
+++ b/mm2src/coins/siacoin.rs
@@ -403,7 +403,9 @@ impl SwapOps for SiaCoin {
         unimplemented!()
     }
 
-    fn send_maker_payment(&self, _maker_payment_args: SendPaymentArgs) -> TransactionFut { unimplemented!() }
+    async fn send_maker_payment(&self, _maker_payment_args: SendPaymentArgs<'_>) -> TransactionResult {
+        unimplemented!()
+    }
 
     fn send_taker_payment(&self, _taker_payment_args: SendPaymentArgs) -> TransactionFut { unimplemented!() }
 
diff --git a/mm2src/coins/tendermint/tendermint_coin.rs b/mm2src/coins/tendermint/tendermint_coin.rs
index de1753cffe..1871ccacb4 100644
--- a/mm2src/coins/tendermint/tendermint_coin.rs
+++ b/mm2src/coins/tendermint/tendermint_coin.rs
@@ -2702,7 +2702,7 @@ impl SwapOps for TendermintCoin {
         )
     }
 
-    fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs) -> TransactionFut {
+    async fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs<'_>) -> TransactionResult {
         self.send_htlc_for_denom(
             maker_payment_args.time_lock_duration,
             maker_payment_args.other_pubkey,
@@ -2711,6 +2711,8 @@ impl SwapOps for TendermintCoin {
             self.denom.clone(),
             self.decimals,
         )
+        .compat()
+        .await
     }
 
     fn send_taker_payment(&self, taker_payment_args: SendPaymentArgs) -> TransactionFut {
diff --git a/mm2src/coins/tendermint/tendermint_token.rs b/mm2src/coins/tendermint/tendermint_token.rs
index 3e63589926..1115065cdf 100644
--- a/mm2src/coins/tendermint/tendermint_token.rs
+++ b/mm2src/coins/tendermint/tendermint_token.rs
@@ -115,15 +115,18 @@ impl SwapOps for TendermintToken {
         )
     }
 
-    fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs) -> TransactionFut {
-        self.platform_coin.send_htlc_for_denom(
-            maker_payment_args.time_lock_duration,
-            maker_payment_args.other_pubkey,
-            maker_payment_args.secret_hash,
-            maker_payment_args.amount,
-            self.denom.clone(),
-            self.decimals,
-        )
+    async fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs<'_>) -> TransactionResult {
+        self.platform_coin
+            .send_htlc_for_denom(
+                maker_payment_args.time_lock_duration,
+                maker_payment_args.other_pubkey,
+                maker_payment_args.secret_hash,
+                maker_payment_args.amount,
+                self.denom.clone(),
+                self.decimals,
+            )
+            .compat()
+            .await
     }
 
     fn send_taker_payment(&self, taker_payment_args: SendPaymentArgs) -> TransactionFut {
diff --git a/mm2src/coins/test_coin.rs b/mm2src/coins/test_coin.rs
index 10b057ee77..541be9e4d2 100644
--- a/mm2src/coins/test_coin.rs
+++ b/mm2src/coins/test_coin.rs
@@ -118,7 +118,9 @@ impl SwapOps for TestCoin {
         unimplemented!()
     }
 
-    fn send_maker_payment(&self, _maker_payment_args: SendPaymentArgs) -> TransactionFut { unimplemented!() }
+    async fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs<'_>) -> TransactionResult {
+        unimplemented!()
+    }
 
     fn send_taker_payment(&self, _taker_payment_args: SendPaymentArgs) -> TransactionFut { unimplemented!() }
 
diff --git a/mm2src/coins/utxo/bch.rs b/mm2src/coins/utxo/bch.rs
index f2cf7b4251..c2d1d5b62b 100644
--- a/mm2src/coins/utxo/bch.rs
+++ b/mm2src/coins/utxo/bch.rs
@@ -875,8 +875,10 @@ impl SwapOps for BchCoin {
     }
 
     #[inline]
-    fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs) -> TransactionFut {
+    async fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs<'_>) -> TransactionResult {
         utxo_common::send_maker_payment(self.clone(), maker_payment_args)
+            .compat()
+            .await
     }
 
     #[inline]
diff --git a/mm2src/coins/utxo/qtum.rs b/mm2src/coins/utxo/qtum.rs
index d3442d6690..682b2a9ff0 100644
--- a/mm2src/coins/utxo/qtum.rs
+++ b/mm2src/coins/utxo/qtum.rs
@@ -515,8 +515,10 @@ impl SwapOps for QtumCoin {
     }
 
     #[inline]
-    fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs) -> TransactionFut {
+    async fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs<'_>) -> TransactionResult {
         utxo_common::send_maker_payment(self.clone(), maker_payment_args)
+            .compat()
+            .await
     }
 
     #[inline]
diff --git a/mm2src/coins/utxo/slp.rs b/mm2src/coins/utxo/slp.rs
index 503611445e..bce9902319 100644
--- a/mm2src/coins/utxo/slp.rs
+++ b/mm2src/coins/utxo/slp.rs
@@ -1238,22 +1238,18 @@ impl SwapOps for SlpToken {
         Box::new(fut.boxed().compat().map(|tx| tx.into()))
     }
 
-    fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs) -> TransactionFut {
-        let taker_pub = try_tx_fus!(Public::from_slice(maker_payment_args.other_pubkey));
-        let amount = try_tx_fus!(sat_from_big_decimal(&maker_payment_args.amount, self.decimals()));
+    async fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs<'_>) -> TransactionResult {
+        let taker_pub = try_tx_s!(Public::from_slice(maker_payment_args.other_pubkey));
+        let amount = try_tx_s!(sat_from_big_decimal(&maker_payment_args.amount, self.decimals()));
         let secret_hash = maker_payment_args.secret_hash.to_owned();
         let maker_htlc_keypair = self.derive_htlc_key_pair(maker_payment_args.swap_unique_data);
-        let time_lock = try_tx_fus!(maker_payment_args.time_lock.try_into());
+        let time_lock = try_tx_s!(maker_payment_args.time_lock.try_into());
 
-        let coin = self.clone();
-        let fut = async move {
-            let tx = try_tx_s!(
-                coin.send_htlc(maker_htlc_keypair.public(), &taker_pub, time_lock, &secret_hash, amount)
-                    .await
-            );
-            Ok(tx.into())
-        };
-        Box::new(fut.boxed().compat())
+        let tx = try_tx_s!(
+            self.send_htlc(maker_htlc_keypair.public(), &taker_pub, time_lock, &secret_hash, amount)
+                .await
+        );
+        Ok(tx.into())
     }
 
     fn send_taker_payment(&self, taker_payment_args: SendPaymentArgs) -> TransactionFut {
diff --git a/mm2src/coins/utxo/utxo_standard.rs b/mm2src/coins/utxo/utxo_standard.rs
index d55ce40420..a8627e86d9 100644
--- a/mm2src/coins/utxo/utxo_standard.rs
+++ b/mm2src/coins/utxo/utxo_standard.rs
@@ -307,8 +307,10 @@ impl SwapOps for UtxoStandardCoin {
     }
 
     #[inline]
-    fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs) -> TransactionFut {
+    async fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs<'_>) -> TransactionResult {
         utxo_common::send_maker_payment(self.clone(), maker_payment_args)
+            .compat()
+            .await
     }
 
     #[inline]
diff --git a/mm2src/coins/z_coin.rs b/mm2src/coins/z_coin.rs
index 81d0aca85c..348676e548 100644
--- a/mm2src/coins/z_coin.rs
+++ b/mm2src/coins/z_coin.rs
@@ -1210,28 +1210,24 @@ impl SwapOps for ZCoin {
         Box::new(fut.boxed().compat())
     }
 
-    fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs<'_>) -> TransactionFut {
-        let selfi = self.clone();
+    async fn send_maker_payment(&self, maker_payment_args: SendPaymentArgs<'_>) -> TransactionResult {
         let maker_key_pair = self.derive_htlc_key_pair(maker_payment_args.swap_unique_data);
-        let taker_pub = try_tx_fus!(Public::from_slice(maker_payment_args.other_pubkey));
+        let taker_pub = try_tx_s!(Public::from_slice(maker_payment_args.other_pubkey));
         let secret_hash = maker_payment_args.secret_hash.to_vec();
-        let time_lock = try_tx_fus!(maker_payment_args.time_lock.try_into());
+        let time_lock = try_tx_s!(maker_payment_args.time_lock.try_into());
         let amount = maker_payment_args.amount;
-        let fut = async move {
-            let utxo_tx = try_tx_s!(
-                z_send_htlc(
-                    &selfi,
-                    time_lock,
-                    maker_key_pair.public(),
-                    &taker_pub,
-                    &secret_hash,
-                    amount
-                )
-                .await
-            );
-            Ok(utxo_tx.into())
-        };
-        Box::new(fut.boxed().compat())
+        let utxo_tx = try_tx_s!(
+            z_send_htlc(
+                self,
+                time_lock,
+                maker_key_pair.public(),
+                &taker_pub,
+                &secret_hash,
+                amount
+            )
+            .await
+        );
+        Ok(utxo_tx.into())
     }
 
     fn send_taker_payment(&self, taker_payment_args: SendPaymentArgs<'_>) -> TransactionFut {
diff --git a/mm2src/coins/z_coin/z_coin_native_tests.rs b/mm2src/coins/z_coin/z_coin_native_tests.rs
index 790f42818f..713eb7c930 100644
--- a/mm2src/coins/z_coin/z_coin_native_tests.rs
+++ b/mm2src/coins/z_coin/z_coin_native_tests.rs
@@ -54,7 +54,7 @@ fn zombie_coin_send_and_refund_maker_payment() {
         watcher_reward: None,
         wait_for_confirmation_until: 0,
     };
-    let tx = block_on_f01(coin.send_maker_payment(args)).unwrap();
+    let tx = block_on(coin.send_maker_payment(args)).unwrap();
     log!("swap tx {}", hex::encode(tx.tx_hash_as_bytes().0));
 
     let refund_args = RefundPaymentArgs {
@@ -115,7 +115,7 @@ fn zombie_coin_send_and_spend_maker_payment() {
         wait_for_confirmation_until: 0,
     };
 
-    let tx = block_on_f01(coin.send_maker_payment(maker_payment_args)).unwrap();
+    let tx = block_on(coin.send_maker_payment(maker_payment_args)).unwrap();
     log!("swap tx {}", hex::encode(tx.tx_hash_as_bytes().0));
 
     let maker_pub = taker_pub;
diff --git a/mm2src/mm2_main/src/lp_swap/maker_swap.rs b/mm2src/mm2_main/src/lp_swap/maker_swap.rs
index 812e7c366a..7f6982df3a 100644
--- a/mm2src/mm2_main/src/lp_swap/maker_swap.rs
+++ b/mm2src/mm2_main/src/lp_swap/maker_swap.rs
@@ -794,7 +794,8 @@ impl MakerSwap {
     }
 
     async fn maker_payment(&self) -> Result<(Option<MakerSwapCommand>, Vec<MakerSwapEvent>), String> {
-        let timeout = self.r().data.started_at + self.r().data.lock_duration / 3;
+        let lock_duration = self.r().data.lock_duration;
+        let timeout = self.r().data.started_at + lock_duration / 3;
         let now = now_sec();
         if now > timeout {
             return Ok((Some(MakerSwapCommand::Finish), vec![
@@ -802,24 +803,27 @@ impl MakerSwap {
             ]));
         }
 
+        let maker_payment_lock = self.r().data.maker_payment_lock;
+        let other_maker_coin_htlc_pub = self.r().other_maker_coin_htlc_pub;
         let secret_hash = self.secret_hash();
+        let maker_coin_swap_contract_address = self.r().data.maker_coin_swap_contract_address.clone();
         let unique_data = self.unique_swap_data();
+        let payment_instructions = self.r().payment_instructions.clone();
         let transaction_f = self
             .maker_coin
             .check_if_my_payment_sent(CheckIfMyPaymentSentArgs {
-                time_lock: self.r().data.maker_payment_lock,
-                other_pub: &*self.r().other_maker_coin_htlc_pub,
+                time_lock: maker_payment_lock,
+                other_pub: &*other_maker_coin_htlc_pub,
                 secret_hash: secret_hash.as_slice(),
                 search_from_block: self.r().data.maker_coin_start_block,
-                swap_contract_address: &self.r().data.maker_coin_swap_contract_address,
+                swap_contract_address: &maker_coin_swap_contract_address,
                 swap_unique_data: &unique_data,
                 amount: &self.maker_amount,
-                payment_instructions: &self.r().payment_instructions,
+                payment_instructions: &payment_instructions,
             })
             .compat();
 
-        let wait_maker_payment_until =
-            wait_for_maker_payment_conf_until(self.r().data.started_at, self.r().data.lock_duration);
+        let wait_maker_payment_until = wait_for_maker_payment_conf_until(self.r().data.started_at, lock_duration);
         let watcher_reward = if self.r().watcher_reward {
             match self
                 .maker_coin
@@ -841,20 +845,23 @@ impl MakerSwap {
             Ok(res) => match res {
                 Some(tx) => tx,
                 None => {
-                    let payment_fut = self.maker_coin.send_maker_payment(SendPaymentArgs {
-                        time_lock_duration: self.r().data.lock_duration,
-                        time_lock: self.r().data.maker_payment_lock,
-                        other_pubkey: &*self.r().other_maker_coin_htlc_pub,
-                        secret_hash: secret_hash.as_slice(),
-                        amount: self.maker_amount.clone(),
-                        swap_contract_address: &self.r().data.maker_coin_swap_contract_address,
-                        swap_unique_data: &unique_data,
-                        payment_instructions: &self.r().payment_instructions,
-                        watcher_reward,
-                        wait_for_confirmation_until: wait_maker_payment_until,
-                    });
-
-                    match payment_fut.compat().await {
+                    let payment = self
+                        .maker_coin
+                        .send_maker_payment(SendPaymentArgs {
+                            time_lock_duration: lock_duration,
+                            time_lock: maker_payment_lock,
+                            other_pubkey: &*other_maker_coin_htlc_pub,
+                            secret_hash: secret_hash.as_slice(),
+                            amount: self.maker_amount.clone(),
+                            swap_contract_address: &maker_coin_swap_contract_address,
+                            swap_unique_data: &unique_data,
+                            payment_instructions: &payment_instructions,
+                            watcher_reward,
+                            wait_for_confirmation_until: wait_maker_payment_until,
+                        })
+                        .await;
+
+                    match payment {
                         Ok(t) => t,
                         Err(err) => {
                             return Ok((Some(MakerSwapCommand::Finish), vec![
diff --git a/mm2src/mm2_main/tests/docker_tests/docker_tests_inner.rs b/mm2src/mm2_main/tests/docker_tests/docker_tests_inner.rs
index fd9e4eefb6..c80fbd665b 100644
--- a/mm2src/mm2_main/tests/docker_tests/docker_tests_inner.rs
+++ b/mm2src/mm2_main/tests/docker_tests/docker_tests_inner.rs
@@ -139,7 +139,7 @@ fn test_search_for_swap_tx_spend_native_was_refunded_maker() {
         watcher_reward: None,
         wait_for_confirmation_until: 0,
     };
-    let tx = block_on_f01(coin.send_maker_payment(maker_payment_args)).unwrap();
+    let tx = block_on(coin.send_maker_payment(maker_payment_args)).unwrap();
 
     let confirm_payment_input = ConfirmPaymentInput {
         payment_tx: tx.tx_hex(),
@@ -276,7 +276,7 @@ fn test_search_for_maker_swap_tx_spend_native_was_spent_by_taker() {
         watcher_reward: None,
         wait_for_confirmation_until: 0,
     };
-    let tx = block_on_f01(coin.send_maker_payment(maker_payment_args)).unwrap();
+    let tx = block_on(coin.send_maker_payment(maker_payment_args)).unwrap();
 
     let confirm_payment_input = ConfirmPaymentInput {
         payment_tx: tx.tx_hex(),
@@ -347,7 +347,7 @@ fn test_one_hundred_maker_payments_in_a_row_native() {
             watcher_reward: None,
             wait_for_confirmation_until: 0,
         };
-        let tx = block_on_f01(coin.send_maker_payment(maker_payment_args)).unwrap();
+        let tx = block_on(coin.send_maker_payment(maker_payment_args)).unwrap();
         if let TransactionEnum::UtxoTx(tx) = tx {
             unspents.push(UnspentInfo {
                 outpoint: OutPoint {
diff --git a/mm2src/mm2_main/tests/docker_tests/eth_docker_tests.rs b/mm2src/mm2_main/tests/docker_tests/eth_docker_tests.rs
index cc44cb5af1..293610e102 100644
--- a/mm2src/mm2_main/tests/docker_tests/eth_docker_tests.rs
+++ b/mm2src/mm2_main/tests/docker_tests/eth_docker_tests.rs
@@ -539,7 +539,7 @@ fn send_and_refund_eth_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy) {
         watcher_reward: None,
         wait_for_confirmation_until: 0,
     };
-    let eth_maker_payment = block_on_f01(eth_coin.send_maker_payment(send_payment_args)).unwrap();
+    let eth_maker_payment = block_on(eth_coin.send_maker_payment(send_payment_args)).unwrap();
 
     let confirm_input = ConfirmPaymentInput {
         payment_tx: eth_maker_payment.tx_hex(),
@@ -625,7 +625,7 @@ fn send_and_spend_eth_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy) {
         watcher_reward: None,
         wait_for_confirmation_until: 0,
     };
-    let eth_maker_payment = block_on_f01(maker_eth_coin.send_maker_payment(send_payment_args)).unwrap();
+    let eth_maker_payment = block_on(maker_eth_coin.send_maker_payment(send_payment_args)).unwrap();
 
     let confirm_input = ConfirmPaymentInput {
         payment_tx: eth_maker_payment.tx_hex(),
@@ -708,7 +708,7 @@ fn send_and_refund_erc20_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy)
         watcher_reward: None,
         wait_for_confirmation_until: now_sec() + 60,
     };
-    let eth_maker_payment = block_on_f01(erc20_coin.send_maker_payment(send_payment_args)).unwrap();
+    let eth_maker_payment = block_on(erc20_coin.send_maker_payment(send_payment_args)).unwrap();
 
     let confirm_input = ConfirmPaymentInput {
         payment_tx: eth_maker_payment.tx_hex(),
@@ -797,7 +797,7 @@ fn send_and_spend_erc20_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy) {
         watcher_reward: None,
         wait_for_confirmation_until: now_sec() + 60,
     };
-    let eth_maker_payment = block_on_f01(maker_erc20_coin.send_maker_payment(send_payment_args)).unwrap();
+    let eth_maker_payment = block_on(maker_erc20_coin.send_maker_payment(send_payment_args)).unwrap();
 
     let confirm_input = ConfirmPaymentInput {
         payment_tx: eth_maker_payment.tx_hex(),
diff --git a/mm2src/mm2_main/tests/docker_tests/qrc20_tests.rs b/mm2src/mm2_main/tests/docker_tests/qrc20_tests.rs
index 6d8d03d96c..0b6213920e 100644
--- a/mm2src/mm2_main/tests/docker_tests/qrc20_tests.rs
+++ b/mm2src/mm2_main/tests/docker_tests/qrc20_tests.rs
@@ -185,7 +185,7 @@ fn test_taker_spends_maker_payment() {
         watcher_reward: None,
         wait_for_confirmation_until: 0,
     };
-    let payment = block_on_f01(maker_coin.send_maker_payment(maker_payment_args)).unwrap();
+    let payment = block_on(maker_coin.send_maker_payment(maker_payment_args)).unwrap();
     let payment_tx_hash = payment.tx_hash_as_bytes();
     let payment_tx_hex = payment.tx_hex();
     log!("Maker payment: {:?}", payment_tx_hash);
@@ -360,7 +360,7 @@ fn test_maker_refunds_payment() {
         watcher_reward: None,
         wait_for_confirmation_until: 0,
     };
-    let payment = block_on_f01(coin.send_maker_payment(maker_payment)).unwrap();
+    let payment = block_on(coin.send_maker_payment(maker_payment)).unwrap();
     let payment_tx_hash = payment.tx_hash_as_bytes();
     let payment_tx_hex = payment.tx_hex();
     log!("Maker payment: {:?}", payment_tx_hash);
@@ -501,7 +501,7 @@ fn test_check_if_my_payment_sent() {
         watcher_reward: None,
         wait_for_confirmation_until: 0,
     };
-    let payment = block_on_f01(coin.send_maker_payment(maker_payment_args)).unwrap();
+    let payment = block_on(coin.send_maker_payment(maker_payment_args)).unwrap();
     let payment_tx_hash = payment.tx_hash_as_bytes();
     let payment_tx_hex = payment.tx_hex();
     log!("Maker payment: {:?}", payment_tx_hash);
@@ -558,7 +558,7 @@ fn test_search_for_swap_tx_spend_taker_spent() {
         watcher_reward: None,
         wait_for_confirmation_until: 0,
     };
-    let payment = block_on_f01(maker_coin.send_maker_payment(maker_payment_args)).unwrap();
+    let payment = block_on(maker_coin.send_maker_payment(maker_payment_args)).unwrap();
     let payment_tx_hash = payment.tx_hash_as_bytes();
     let payment_tx_hex = payment.tx_hex();
     log!("Maker payment: {:?}", payment_tx_hash);
@@ -637,7 +637,7 @@ fn test_search_for_swap_tx_spend_maker_refunded() {
         watcher_reward: None,
         wait_for_confirmation_until: 0,
     };
-    let payment = block_on_f01(maker_coin.send_maker_payment(maker_payment_args)).unwrap();
+    let payment = block_on(maker_coin.send_maker_payment(maker_payment_args)).unwrap();
     let payment_tx_hash = payment.tx_hash_as_bytes();
     let payment_tx_hex = payment.tx_hex();
     log!("Maker payment: {:?}", payment_tx_hash);
@@ -717,7 +717,7 @@ fn test_search_for_swap_tx_spend_not_spent() {
         watcher_reward: None,
         wait_for_confirmation_until: 0,
     };
-    let payment = block_on_f01(maker_coin.send_maker_payment(maker_payment_args)).unwrap();
+    let payment = block_on(maker_coin.send_maker_payment(maker_payment_args)).unwrap();
     let payment_tx_hash = payment.tx_hash_as_bytes();
     let payment_tx_hex = payment.tx_hex();
     log!("Maker payment: {:?}", payment_tx_hash);
@@ -774,7 +774,7 @@ fn test_wait_for_tx_spend() {
         watcher_reward: None,
         wait_for_confirmation_until: 0,
     };
-    let payment = block_on_f01(maker_coin.send_maker_payment(maker_payment_args)).unwrap();
+    let payment = block_on(maker_coin.send_maker_payment(maker_payment_args)).unwrap();
     let payment_tx_hash = payment.tx_hash_as_bytes();
     let payment_tx_hex = payment.tx_hex();
     log!("Maker payment: {:?}", payment_tx_hash);
@@ -1483,7 +1483,7 @@ fn test_search_for_segwit_swap_tx_spend_native_was_refunded_maker() {
         watcher_reward: None,
         wait_for_confirmation_until: 0,
     };
-    let tx = block_on_f01(coin.send_maker_payment(maker_payment)).unwrap();
+    let tx = block_on(coin.send_maker_payment(maker_payment)).unwrap();
 
     let confirm_payment_input = ConfirmPaymentInput {
         payment_tx: tx.tx_hex(),
diff --git a/mm2src/mm2_main/tests/docker_tests/swap_watcher_tests.rs b/mm2src/mm2_main/tests/docker_tests/swap_watcher_tests.rs
index dc6f8cb5ba..83de612a31 100644
--- a/mm2src/mm2_main/tests/docker_tests/swap_watcher_tests.rs
+++ b/mm2src/mm2_main/tests/docker_tests/swap_watcher_tests.rs
@@ -2666,7 +2666,7 @@ fn test_taker_validates_maker_payment_spend_utxo() {
     let secret = generate_secret().unwrap();
     let secret_hash = dhash160(&secret);
 
-    let maker_payment = block_on_f01(maker_coin.send_maker_payment(SendPaymentArgs {
+    let maker_payment = block_on(maker_coin.send_maker_payment(SendPaymentArgs {
         time_lock_duration,
         time_lock,
         other_pubkey: taker_pubkey,
@@ -2752,7 +2752,7 @@ fn test_taker_validates_maker_payment_spend_eth() {
     .unwrap()
     .unwrap();
 
-    let maker_payment = block_on_f01(maker_coin.send_maker_payment(SendPaymentArgs {
+    let maker_payment = block_on(maker_coin.send_maker_payment(SendPaymentArgs {
         time_lock_duration,
         time_lock,
         other_pubkey: taker_pub,
@@ -3054,7 +3054,7 @@ fn test_taker_validates_maker_payment_spend_erc20() {
     ))
     .unwrap();
 
-    let maker_payment = block_on_f01(maker_coin.send_maker_payment(SendPaymentArgs {
+    let maker_payment = block_on(maker_coin.send_maker_payment(SendPaymentArgs {
         time_lock_duration,
         time_lock,
         other_pubkey: taker_pub,