feat(tpu): implement 0 dexfee for kmd trading pairs

mm2src/coins/eth.rs

@@ -5799,10 +5799,10 @@ impl MmCoin for EthCoin {
         stage: FeeApproxStage,
     ) -> TradePreimageResult<TradeFee> {
         let dex_fee_amount = wei_from_big_decimal(&dex_fee_amount.fee_amount().into(), self.decimals)?;
-
         // pass the dummy params
         let to_addr = addr_from_raw_pubkey(&DEX_FEE_ADDR_RAW_PUBKEY)
             .expect("addr_from_raw_pubkey should never fail with DEX_FEE_ADDR_RAW_PUBKEY");
+        let my_address = self.derivation_method.single_addr_or_err().await?;
         let (eth_value, data, call_addr, fee_coin) = match &self.coin_type {
             EthCoinType::Eth => (dex_fee_amount, Vec::new(), &to_addr, &self.ticker),
             EthCoinType::Erc20 { platform, token_addr } => {
@@ -5812,8 +5812,6 @@ impl MmCoin for EthCoin {
             },
             EthCoinType::Nft { .. } => return MmError::err(TradePreimageError::NftProtocolNotSupported),
         };
-
-        let my_address = self.derivation_method.single_addr_or_err().await?;
         let fee_policy_for_estimate = get_swap_fee_policy_for_estimate(self.get_swap_transaction_fee_policy());
         let pay_for_gas_option = self.get_swap_pay_for_gas_option(fee_policy_for_estimate).await?;
         let pay_for_gas_option = increase_gas_price_by_stage(pay_for_gas_option, &stage);

mm2src/coins/eth/eth_tests.rs

@@ -506,7 +506,7 @@ fn test_get_fee_to_send_taker_fee() {
 
     let (_ctx, coin) = eth_coin_for_test(EthCoinType::Eth, &["http://dummy.dummy"], None, ETH_SEPOLIA_CHAIN_ID);
     let actual = block_on(coin.get_fee_to_send_taker_fee(
-        DexFee::Standard(MmNumber::from(dex_fee_amount.clone())),
+        DexFee::Standard(MmNumber::from(&dex_fee_amount)),
         FeeApproxStage::WithoutApprox,
     ))
     .expect("!get_fee_to_send_taker_fee");

mm2src/coins/lp_coins.rs

@@ -3927,8 +3927,7 @@ impl DexFee {
     /// Gets the burn amount associated with the dex fee, if applicable.
     pub fn burn_amount(&self) -> Option<MmNumber> {
         match self {
-            DexFee::NoFee => None,
-            DexFee::Standard(_) => None,
+            DexFee::Standard(_) | DexFee::NoFee => None,
             DexFee::WithBurn { burn_amount, .. } => Some(burn_amount.clone()),
         }
     }

mm2src/coins/utxo/slp.rs

@@ -1727,6 +1727,7 @@ impl MmCoin for SlpToken {
             &stage,
         )
         .await?;
+
         Ok(TradeFee {
             coin: self.platform_coin.ticker().into(),
             amount: fee.into(),

mm2src/mm2_main/src/lp_swap/maker_swap.rs

@@ -2388,7 +2388,7 @@ pub async fn calc_max_maker_vol(
 ) -> CheckBalanceResult<CoinVolumeInfo> {
     let ticker = coin.ticker();
     let locked_by_swaps = get_locked_amount(ctx, ticker);
-    let available = &MmNumber::from(balance.clone()) - &locked_by_swaps;
+    let available = &MmNumber::from(balance) - &locked_by_swaps;
     let mut volume = available.clone();
 
     let preimage_value = TradePreimageValue::UpperBound(volume.to_decimal());
@@ -2418,7 +2418,7 @@ pub async fn calc_max_maker_vol(
     }
     Ok(CoinVolumeInfo {
         volume,
-        balance: MmNumber::from(balance.clone()),
+        balance: MmNumber::from(balance),
         locked_by_swaps,
     })
 }

mm2src/mm2_main/src/lp_swap/maker_swap_v2.rs

@@ -434,17 +434,27 @@ impl<MakerCoin: MmCoin + MakerCoinSwapOpsV2, TakerCoin: MmCoin + TakerCoinSwapOp
 
     /// Calculate dex fee while taker pub is not known yet
     fn dex_fee(&self) -> DexFee {
-        DexFee::new_from_taker_coin(&self.taker_coin, self.maker_coin.ticker(), &self.taker_volume)
+        // Set DexFee::NoFee for swaps with KMD coin.
+        if self.maker_coin.ticker() == "KMD" || self.taker_coin.ticker() == "KMD" {
+            DexFee::NoFee
+        } else {
+            DexFee::new_from_taker_coin(&self.taker_coin, self.maker_coin.ticker(), &self.taker_volume)
+        }
     }
 
     /// Calculate updated dex fee when taker pub is already received
     fn dex_fee_updated(&self, taker_pub: &[u8]) -> DexFee {
-        DexFee::new_with_taker_pubkey(
-            &self.taker_coin,
-            self.maker_coin.ticker(),
-            &self.taker_volume,
-            taker_pub,
-        )
+        // Set DexFee::NoFee for swaps with KMD coin.
+        if self.maker_coin.ticker() == "KMD" || self.taker_coin.ticker() == "KMD" {
+            DexFee::NoFee
+        } else {
+            DexFee::new_with_taker_pubkey(
+                &self.taker_coin,
+                self.maker_coin.ticker(),
+                &self.taker_volume,
+                taker_pub,
+            )
+        }
     }
 }
 

mm2src/mm2_main/src/lp_swap/taker_swap_v2.rs

@@ -465,6 +465,11 @@ impl<MakerCoin: MmCoin + MakerCoinSwapOpsV2, TakerCoin: MmCoin + TakerCoinSwapOp
     }
 
     fn dex_fee(&self) -> DexFee {
+        if self.taker_coin.ticker() == "KMD" || self.maker_coin.ticker() == "KMD" {
+            // Set DexFee::NoFee for swaps with KMD coin.
+            return DexFee::NoFee;
+        }
+
         if let Some(taker_pub) = self.taker_coin.taker_pubkey_bytes() {
             // for dex fee calculation we need only permanent (non-derived for HTLC) taker pubkey here
             DexFee::new_with_taker_pubkey(

mm2src/mm2_main/tests/docker_tests/docker_tests_common.rs

@@ -1608,7 +1608,7 @@ pub fn init_geth_node() {
             SEPOLIA_ETOMIC_MAKER_NFT_SWAP_V2 =
                 EthAddress::from_str("0x9eb88cd58605d8fb9b14652d6152727f7e95fb4d").unwrap();
             SEPOLIA_ERC20_CONTRACT = EthAddress::from_str("0xF7b5F8E8555EF7A743f24D3E974E23A3C6cB6638").unwrap();
-            SEPOLIA_TAKER_SWAP_V2 = EthAddress::from_str("0x7Cc9F2c1c3B797D09B9d1CCd7FDcD2539a4b3874").unwrap();
+            SEPOLIA_TAKER_SWAP_V2 = EthAddress::from_str("0x3B19873b81a6B426c8B2323955215F7e89CfF33F").unwrap();
             // deploy tx https://sepolia.etherscan.io/tx/0x6f743d79ecb806f5899a6a801083e33eba9e6f10726af0873af9f39883db7f11
             SEPOLIA_MAKER_SWAP_V2 = EthAddress::from_str("0xf9000589c66Df3573645B59c10aa87594Edc318F").unwrap();
         }

mm2src/mm2_main/tests/docker_tests/eth_docker_tests.rs

@@ -1802,7 +1802,7 @@ fn taker_send_approve_and_spend_erc20() {
     let taker_address = block_on(taker_coin.my_addr());
     let maker_address = block_on(maker_coin.my_addr());
 
-    let dex_fee = &DexFee::Standard("0.00001".into());
+    let dex_fee = &DexFee::NoFee;
     let trading_amount = BigDecimal::from_str("0.0001").unwrap();
 
     let maker_pub = &maker_coin.derive_htlc_pubkey_v2(&[]);

mm2src/mm2_number/src/mm_number.rs

@@ -103,6 +103,10 @@ impl From<BigDecimal> for MmNumber {
     fn from(n: BigDecimal) -> MmNumber { from_dec_to_ratio(&n).into() }
 }
 
+impl From<&BigDecimal> for MmNumber {
+    fn from(n: &BigDecimal) -> MmNumber { from_dec_to_ratio(n).into() }
+}
+
 impl From<BigRational> for MmNumber {
     fn from(r: BigRational) -> MmNumber { MmNumber(r) }
 }