feat(trading-proto-upgrade): fees fixes among other things

mm2src/coins/eth.rs

@@ -7418,9 +7418,9 @@ impl TakerCoinSwapOpsV2 for EthCoin {
     }
 
     /// Eth doesnt have preimages
-    async fn gen_taker_funding_spend_preimage(
+    async fn gen_taker_payment_preimage(
         &self,
-        args: &GenTakerFundingSpendArgs<'_, Self>,
+        args: &GenTakerPaymentPreimageArgs<'_, Self>,
         _swap_unique_data: &[u8],
     ) -> GenPreimageResult<Self> {
         Ok(TxPreimageWithSig {
@@ -7430,19 +7430,19 @@ impl TakerCoinSwapOpsV2 for EthCoin {
     }
 
     /// Eth doesnt have preimages
-    async fn validate_taker_funding_spend_preimage(
+    async fn validate_taker_payment_preimage(
         &self,
-        _gen_args: &GenTakerFundingSpendArgs<'_, Self>,
+        _gen_args: &GenTakerPaymentPreimageArgs<'_, Self>,
         _preimage: &TxPreimageWithSig<Self>,
     ) -> ValidateTakerFundingSpendPreimageResult {
         Ok(())
     }
 
     /// Wrapper for [EthCoin::taker_payment_approve]
-    async fn sign_and_send_taker_funding_spend(
+    async fn sign_and_send_taker_payment(
         &self,
         _preimage: &TxPreimageWithSig<Self>,
-        args: &GenTakerFundingSpendArgs<'_, Self>,
+        args: &GenTakerPaymentPreimageArgs<'_, Self>,
         _swap_unique_data: &[u8],
     ) -> Result<Self::Tx, TransactionErr> {
         self.taker_payment_approve(args).await
@@ -7505,6 +7505,12 @@ impl TakerCoinSwapOpsV2 for EthCoin {
     async fn extract_secret_v2(&self, _secret_hash: &[u8], spend_tx: &Self::Tx) -> Result<[u8; 32], String> {
         self.extract_secret_v2_impl(spend_tx).await
     }
+
+    async fn get_funding_fee(&self, _value: TradePreimageValue) -> TradePreimageResult<TradeFee> { todo!() }
+
+    async fn get_taker_payment_fee(&self) -> TradePreimageResult<TradeFee> { todo!() }
+
+    async fn get_taker_payment_spend_fee(&self) -> TradePreimageResult<TradeFee> { todo!() }
 }
 
 impl CommonSwapOpsV2 for EthCoin {
@@ -7612,4 +7618,8 @@ impl MakerCoinSwapOpsV2 for EthCoin {
     async fn spend_maker_payment_v2(&self, args: SpendMakerPaymentArgs<'_, Self>) -> Result<Self::Tx, TransactionErr> {
         self.spend_maker_payment_v2_impl(args).await
     }
+
+    async fn get_maker_payment_fee(&self, _value: TradePreimageValue) -> TradePreimageResult<TradeFee> { todo!() }
+
+    async fn get_maker_payment_spend_fee(&self) -> TradePreimageResult<TradeFee> { todo!() }
 }

mm2src/coins/eth/eth_swap_v2/eth_taker_swap_v2.rs

@@ -4,7 +4,7 @@ use crate::eth::{decode_contract_call, get_function_input_data, wei_from_big_dec
                  ParseCoinAssocTypes, RefundFundingSecretArgs, RefundTakerPaymentArgs, SendTakerFundingArgs,
                  SignedEthTx, SwapTxTypeWithSecretHash, TakerPaymentStateV2, TransactionErr, ValidateSwapV2TxError,
                  ValidateSwapV2TxResult, ValidateTakerFundingArgs, TAKER_SWAP_V2};
-use crate::{FindPaymentSpendError, FundingTxSpend, GenTakerFundingSpendArgs, GenTakerPaymentSpendArgs,
+use crate::{FindPaymentSpendError, FundingTxSpend, GenTakerPaymentPreimageArgs, GenTakerPaymentSpendArgs,
             SearchForFundingSpendErr};
 use derive_more::Display;
 use enum_derives::EnumFromStringify;
@@ -208,7 +208,7 @@ impl EthCoin {
     /// Function accepts taker payment transaction, returns taker approve payment transaction.
     pub(crate) async fn taker_payment_approve(
         &self,
-        args: &GenTakerFundingSpendArgs<'_, Self>,
+        args: &GenTakerPaymentPreimageArgs<'_, Self>,
     ) -> Result<SignedEthTx, TransactionErr> {
         let gas_limit = match self.coin_type {
             EthCoinType::Eth | EthCoinType::Erc20 { .. } => U256::from(self.gas_limit_v2.taker.approve_payment),
@@ -531,7 +531,7 @@ impl EthCoin {
     /// The `decoded` parameter should contain the transaction input data from the `ethTakerPayment` or `erc20TakerPayment` function of the EtomicSwapTakerV2 contract.
     async fn prepare_taker_payment_approve_data(
         &self,
-        args: &GenTakerFundingSpendArgs<'_, Self>,
+        args: &GenTakerPaymentPreimageArgs<'_, Self>,
         decoded: Vec<Token>,
         token_address: Address,
     ) -> Result<Vec<u8>, PrepareTxDataError> {

mm2src/coins/lp_coins.rs

@@ -1370,6 +1370,8 @@ pub struct SendTakerFundingArgs<'a> {
     pub maker_pub: &'a [u8],
     /// DEX fee
     pub dex_fee: &'a DexFee,
+    /// The extra fee added to the trading volume to cover the taker payment transaction fees
+    pub taker_payment_fee: BigDecimal,
     /// Additional reward for maker (premium)
     pub premium_amount: BigDecimal,
     /// Actual volume of taker's payment
@@ -1396,8 +1398,8 @@ pub struct RefundFundingSecretArgs<'a, Coin: ParseCoinAssocTypes + ?Sized> {
     pub watcher_reward: bool,
 }
 
-/// Helper struct wrapping arguments for [TakerCoinSwapOpsV2::gen_taker_funding_spend_preimage]
-pub struct GenTakerFundingSpendArgs<'a, Coin: ParseCoinAssocTypes + ?Sized> {
+/// Helper struct wrapping arguments for [TakerCoinSwapOpsV2::gen_taker_payment_preimage]
+pub struct GenTakerPaymentPreimageArgs<'a, Coin: ParseCoinAssocTypes + ?Sized> {
     /// Taker payment transaction serialized to raw bytes
     pub funding_tx: &'a Coin::Tx,
     /// Maker's pubkey
@@ -1412,6 +1414,8 @@ pub struct GenTakerFundingSpendArgs<'a, Coin: ParseCoinAssocTypes + ?Sized> {
     pub taker_payment_time_lock: u64,
     /// The hash of the secret generated by maker
     pub maker_secret_hash: &'a [u8],
+    /// The extra fee added to the trading volume to cover the taker payment transaction fees
+    pub taker_payment_fee: BigDecimal,
 }
 
 /// Helper struct wrapping arguments for [TakerCoinSwapOpsV2::validate_taker_funding]
@@ -1432,6 +1436,8 @@ pub struct ValidateTakerFundingArgs<'a, Coin: ParseCoinAssocTypes + ?Sized> {
     pub taker_pub: &'a Coin::Pubkey,
     /// DEX fee amount
     pub dex_fee: &'a DexFee,
+    /// The extra fee added to the trading volume to cover the taker payment transaction fees
+    pub taker_payment_fee: BigDecimal,
     /// Additional reward for maker (premium)
     pub premium_amount: BigDecimal,
     /// Actual volume of taker's payment
@@ -1568,6 +1574,8 @@ impl From<PrepareTxDataError> for ValidateSwapV2TxError {
 /// Enum covering error cases that can happen during taker funding spend preimage validation.
 #[derive(Debug, Display, EnumFromStringify)]
 pub enum ValidateTakerFundingSpendPreimageError {
+    /// Error during conversion of BigDecimal amount to coin's specific monetary units (satoshis, wei, etc.).
+    NumConversion(String),
     /// Funding tx has no outputs
     FundingTxNoOutputs,
     /// Actual preimage fee is either too high or too small
@@ -1588,6 +1596,10 @@ pub enum ValidateTakerFundingSpendPreimageError {
     Rpc(String),
 }
 
+impl From<NumConversError> for ValidateTakerFundingSpendPreimageError {
+    fn from(err: NumConversError) -> Self { ValidateTakerFundingSpendPreimageError::NumConversion(err.to_string()) }
+}
+
 impl From<TxGenError> for ValidateTakerFundingSpendPreimageError {
     fn from(err: TxGenError) -> Self { ValidateTakerFundingSpendPreimageError::TxGenError(format!("{:?}", err)) }
 }
@@ -1834,6 +1846,12 @@ pub trait MakerCoinSwapOpsV2: ParseCoinAssocTypes + CommonSwapOpsV2 + Send + Syn
 
     /// Spend maker payment transaction
     async fn spend_maker_payment_v2(&self, args: SpendMakerPaymentArgs<'_, Self>) -> Result<Self::Tx, TransactionErr>;
+
+    /// Get the fee to be paid for the processing of the maker payment transaction.
+    async fn get_maker_payment_fee(&self, value: TradePreimageValue) -> TradePreimageResult<TradeFee>;
+
+    /// Get the fee to be paid for the processing of the maker payment spend transaction aka the claiming transaction.
+    async fn get_maker_payment_spend_fee(&self) -> TradePreimageResult<TradeFee>;
 }
 
 #[async_trait]
@@ -1993,24 +2011,24 @@ pub trait TakerCoinSwapOpsV2: ParseCoinAssocTypes + CommonSwapOpsV2 + Send + Syn
     ) -> Result<Option<FundingTxSpend<Self>>, SearchForFundingSpendErr>;
 
     /// Generates and signs a preimage spending funding tx to the combined taker payment
-    async fn gen_taker_funding_spend_preimage(
+    async fn gen_taker_payment_preimage(
         &self,
-        args: &GenTakerFundingSpendArgs<'_, Self>,
+        args: &GenTakerPaymentPreimageArgs<'_, Self>,
         swap_unique_data: &[u8],
     ) -> GenPreimageResult<Self>;
 
     /// Validates taker funding spend preimage generated and signed by maker
-    async fn validate_taker_funding_spend_preimage(
+    async fn validate_taker_payment_preimage(
         &self,
-        gen_args: &GenTakerFundingSpendArgs<'_, Self>,
+        gen_args: &GenTakerPaymentPreimageArgs<'_, Self>,
         preimage: &TxPreimageWithSig<Self>,
     ) -> ValidateTakerFundingSpendPreimageResult;
 
     /// Sign and send a spending funding tx to the combined taker payment
-    async fn sign_and_send_taker_funding_spend(
+    async fn sign_and_send_taker_payment(
         &self,
         preimage: &TxPreimageWithSig<Self>,
-        args: &GenTakerFundingSpendArgs<'_, Self>,
+        args: &GenTakerPaymentPreimageArgs<'_, Self>,
         swap_unique_data: &[u8],
     ) -> Result<Self::Tx, TransactionErr>;
 
@@ -2056,6 +2074,18 @@ pub trait TakerCoinSwapOpsV2: ParseCoinAssocTypes + CommonSwapOpsV2 + Send + Syn
     ) -> MmResult<Self::Tx, FindPaymentSpendError>;
 
     async fn extract_secret_v2(&self, secret_hash: &[u8], spend_tx: &Self::Tx) -> Result<[u8; 32], String>;
+
+    /// Get the fee to be paid for the processing of the funding transaction.
+    /// Txs in success case (no refund) go as follows:
+    ///    Chain A: funding -> taker payment -> taker payment spend (aka preimage) (to the maker & dex)
+    ///    Chain B:            maker payment -> maker payment spend (aka claiming) (to the taker)
+    async fn get_funding_fee(&self, value: TradePreimageValue) -> TradePreimageResult<TradeFee>;
+
+    /// Get the fee to be paid for the processing of the taker payment transaction.
+    async fn get_taker_payment_fee(&self) -> TradePreimageResult<TradeFee>;
+
+    /// Get the fee to be paid for the processing of the taker payment spend transaction aka the preimage transaction.
+    async fn get_taker_payment_spend_fee(&self) -> TradePreimageResult<TradeFee>;
 }
 
 #[async_trait]

mm2src/coins/test_coin.rs

@@ -6,18 +6,19 @@ use super::{CoinBalance, CommonSwapOpsV2, FindPaymentSpendError, FundingTxSpend,
 use crate::coin_errors::{AddressFromPubkeyError, ValidatePaymentResult};
 use crate::hd_wallet::{AddrToString, HDAddressSelector};
 use crate::{coin_errors::MyAddressError, BalanceFut, CanRefundHtlc, CheckIfMyPaymentSentArgs, ConfirmPaymentInput,
-            FeeApproxStage, FoundSwapTxSpend, GenPreimageResult, GenTakerFundingSpendArgs, GenTakerPaymentSpendArgs,
-            MmCoinEnum, NegotiateSwapContractAddrErr, ParseCoinAssocTypes, PaymentInstructionArgs,
-            PaymentInstructions, PaymentInstructionsErr, RawTransactionResult, RefundFundingSecretArgs,
-            RefundPaymentArgs, RefundResult, SearchForSwapTxSpendInput, SendMakerPaymentSpendPreimageInput,
-            SendPaymentArgs, SendTakerFundingArgs, SignRawTransactionRequest, SignatureResult, SpendPaymentArgs,
-            TakerCoinSwapOpsV2, TradePreimageFut, TradePreimageResult, TradePreimageValue, Transaction,
-            TransactionErr, TransactionResult, TxMarshalingErr, TxPreimageWithSig, UnexpectedDerivationMethod,
-            ValidateAddressResult, ValidateFeeArgs, ValidateInstructionsErr, ValidateOtherPubKeyErr,
-            ValidatePaymentFut, ValidatePaymentInput, ValidateSwapV2TxResult, ValidateTakerFundingArgs,
-            ValidateTakerFundingSpendPreimageResult, ValidateTakerPaymentSpendPreimageResult, VerificationResult,
-            WaitForHTLCTxSpendArgs, WatcherOps, WatcherReward, WatcherRewardError, WatcherSearchForSwapTxSpendInput,
-            WatcherValidatePaymentInput, WatcherValidateTakerFeeInput, WeakSpawner, WithdrawFut, WithdrawRequest};
+            FeeApproxStage, FoundSwapTxSpend, GenPreimageResult, GenTakerPaymentPreimageArgs,
+            GenTakerPaymentSpendArgs, MmCoinEnum, NegotiateSwapContractAddrErr, ParseCoinAssocTypes,
+            PaymentInstructionArgs, PaymentInstructions, PaymentInstructionsErr, RawTransactionResult,
+            RefundFundingSecretArgs, RefundPaymentArgs, RefundResult, SearchForSwapTxSpendInput,
+            SendMakerPaymentSpendPreimageInput, SendPaymentArgs, SendTakerFundingArgs, SignRawTransactionRequest,
+            SignatureResult, SpendPaymentArgs, TakerCoinSwapOpsV2, TradePreimageFut, TradePreimageResult,
+            TradePreimageValue, Transaction, TransactionErr, TransactionResult, TxMarshalingErr, TxPreimageWithSig,
+            UnexpectedDerivationMethod, ValidateAddressResult, ValidateFeeArgs, ValidateInstructionsErr,
+            ValidateOtherPubKeyErr, ValidatePaymentFut, ValidatePaymentInput, ValidateSwapV2TxResult,
+            ValidateTakerFundingArgs, ValidateTakerFundingSpendPreimageResult,
+            ValidateTakerPaymentSpendPreimageResult, VerificationResult, WaitForHTLCTxSpendArgs, WatcherOps,
+            WatcherReward, WatcherRewardError, WatcherSearchForSwapTxSpendInput, WatcherValidatePaymentInput,
+            WatcherValidateTakerFeeInput, WeakSpawner, WithdrawFut, WithdrawRequest};
 use crate::{DexFee, ToBytes, ValidateWatcherSpendInput};
 use async_trait::async_trait;
 use common::executor::AbortedError;
@@ -508,26 +509,26 @@ impl TakerCoinSwapOpsV2 for TestCoin {
         todo!()
     }
 
-    async fn gen_taker_funding_spend_preimage(
+    async fn gen_taker_payment_preimage(
         &self,
-        args: &GenTakerFundingSpendArgs<'_, Self>,
+        args: &GenTakerPaymentPreimageArgs<'_, Self>,
         swap_unique_data: &[u8],
     ) -> GenPreimageResult<Self> {
         todo!()
     }
 
-    async fn validate_taker_funding_spend_preimage(
+    async fn validate_taker_payment_preimage(
         &self,
-        gen_args: &GenTakerFundingSpendArgs<'_, Self>,
+        gen_args: &GenTakerPaymentPreimageArgs<'_, Self>,
         preimage: &TxPreimageWithSig<Self>,
     ) -> ValidateTakerFundingSpendPreimageResult {
         todo!()
     }
 
-    async fn sign_and_send_taker_funding_spend(
+    async fn sign_and_send_taker_payment(
         &self,
         preimage: &TxPreimageWithSig<Self>,
-        args: &GenTakerFundingSpendArgs<'_, Self>,
+        args: &GenTakerPaymentPreimageArgs<'_, Self>,
         swap_unique_data: &[u8],
     ) -> Result<Self::Tx, TransactionErr> {
         todo!()
@@ -578,10 +579,16 @@ impl TakerCoinSwapOpsV2 for TestCoin {
     async fn extract_secret_v2(&self, secret_hash: &[u8], spend_tx: &Self::Tx) -> Result<[u8; 32], String> {
         unimplemented!()
     }
+
+    async fn get_funding_fee(&self, value: TradePreimageValue) -> TradePreimageResult<TradeFee> { todo!() }
+
+    async fn get_taker_payment_fee(&self) -> TradePreimageResult<TradeFee> { todo!() }
+
+    async fn get_taker_payment_spend_fee(&self) -> TradePreimageResult<TradeFee> { todo!() }
 }
 
 impl CommonSwapOpsV2 for TestCoin {
-    fn derive_htlc_pubkey_v2(&self, _swap_unique_data: &[u8]) -> Self::Pubkey { todo!() }
+    fn derive_htlc_pubkey_v2(&self, swap_unique_data: &[u8]) -> Self::Pubkey { todo!() }
 
     fn derive_htlc_pubkey_v2_bytes(&self, _swap_unique_data: &[u8]) -> Vec<u8> { todo!() }
 

mm2src/coins/utxo.rs

@@ -571,7 +571,7 @@ pub struct UtxoCoinConf {
     /// Address and privkey checksum type
     pub checksum_type: ChecksumType,
     /// Fork id used in sighash
-    pub fork_id: u32,
+    pub fork_id: u8,
     /// Signature version
     pub signature_version: SignatureVersion,
     pub required_confirmations: AtomicU64,

mm2src/coins/utxo/qtum.rs

@@ -984,7 +984,7 @@ impl UtxoSignerOps for QtumCoin {
             })
     }
 
-    fn fork_id(&self) -> u32 { self.utxo_arc.conf.fork_id }
+    fn fork_id(&self) -> u8 { self.utxo_arc.conf.fork_id }
 
     fn branch_id(&self) -> u32 { self.utxo_arc.conf.consensus_branch_id }
 

mm2src/coins/utxo/utxo_builder/utxo_conf_builder.rs

@@ -33,6 +33,8 @@ pub enum UtxoConfError {
     InvalidVersionGroupId(String),
     InvalidAddressFormat(String),
     InvalidDecimals(String),
+    #[display(fmt = "Invalid fork id: {}, valid fork ids are values between 0x00 - 0xff", _0)]
+    InvalidForkId(String),
 }
 
 impl From<Bip32Error> for UtxoConfError {
@@ -90,8 +92,8 @@ impl<'a> UtxoConfBuilder<'a> {
         let tx_fee_volatility_percent = self.tx_fee_volatility_percent();
         let version_group_id = self.version_group_id(tx_version, overwintered)?;
         let consensus_branch_id = self.consensus_branch_id(tx_version)?;
-        let signature_version = self.signature_version();
-        let fork_id = self.fork_id();
+        let signature_version = self.signature_version()?;
+        let fork_id = self.fork_id()?;
 
         // should be sufficient to detect zcash by overwintered flag
         let zcash = overwintered;
@@ -242,23 +244,23 @@ impl<'a> UtxoConfBuilder<'a> {
         Ok(consensus_branch_id)
     }
 
-    fn signature_version(&self) -> SignatureVersion {
-        let default_signature_version = if self.ticker == "BCH" || self.fork_id() != 0 {
+    fn signature_version(&self) -> UtxoConfResult<SignatureVersion> {
+        let default_signature_version = if self.ticker == "BCH" || self.fork_id()? != 0 {
             SignatureVersion::ForkId
         } else {
             SignatureVersion::Base
         };
-        json::from_value(self.conf["signature_version"].clone()).unwrap_or(default_signature_version)
+        Ok(json::from_value(self.conf["signature_version"].clone()).unwrap_or(default_signature_version))
     }
 
-    fn fork_id(&self) -> u32 {
+    fn fork_id(&self) -> UtxoConfResult<u8> {
         let default_fork_id = match self.ticker {
             "BCH" => "0x40",
             _ => "0x0",
         };
         let hex_string = self.conf["fork_id"].as_str().unwrap_or(default_fork_id);
-        let fork_id = u32::from_str_radix(hex_string.trim_start_matches("0x"), 16).unwrap();
-        fork_id
+        u8::from_str_radix(hex_string.trim_start_matches("0x"), 16)
+            .map_to_mm(|e| UtxoConfError::InvalidForkId(e.to_string()))
     }
 
     fn required_confirmations(&self) -> u64 {