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

mm2src/coins/eth.rs

@@ -111,23 +111,24 @@ cfg_wasm32! {
 
 use super::{coin_conf, lp_coinfind_or_err, AsyncMutex, BalanceError, BalanceFut, CheckIfMyPaymentSentArgs,
             CoinBalance, CoinFutSpawner, CoinProtocol, CoinTransportMetrics, CoinsContext, ConfirmPaymentInput,
-            EthValidateFeeArgs, FeeApproxStage, FoundSwapTxSpend, HistorySyncState, IguanaPrivKey, MakerSwapTakerCoin,
-            MarketCoinOps, MmCoin, MmCoinEnum, MyAddressError, MyWalletAddress, NegotiateSwapContractAddrErr,
-            NumConversError, NumConversResult, PaymentInstructionArgs, PaymentInstructions, PaymentInstructionsErr,
-            PrivKeyBuildPolicy, PrivKeyPolicyNotAllowed, RawTransactionError, RawTransactionFut,
-            RawTransactionRequest, RawTransactionRes, RawTransactionResult, RefundError, RefundPaymentArgs,
-            RefundResult, RewardTarget, RpcClientType, RpcTransportEventHandler, RpcTransportEventHandlerShared,
-            SearchForSwapTxSpendInput, SendMakerPaymentSpendPreimageInput, SendPaymentArgs, SignEthTransactionParams,
-            SignRawTransactionEnum, SignRawTransactionRequest, SignatureError, SignatureResult, SpendPaymentArgs,
-            SwapOps, SwapTxFeePolicy, TakerSwapMakerCoin, TradeFee, TradePreimageError, TradePreimageFut,
-            TradePreimageResult, TradePreimageValue, Transaction, TransactionDetails, TransactionEnum, TransactionErr,
-            TransactionFut, TransactionType, TxMarshalingErr, UnexpectedDerivationMethod, ValidateAddressResult,
-            ValidateFeeArgs, ValidateInstructionsErr, ValidateOtherPubKeyErr, ValidatePaymentError,
-            ValidatePaymentFut, ValidatePaymentInput, VerificationError, VerificationResult, WaitForHTLCTxSpendArgs,
-            WatcherOps, WatcherReward, WatcherRewardError, WatcherSearchForSwapTxSpendInput,
-            WatcherValidatePaymentInput, WatcherValidateTakerFeeInput, WithdrawError, WithdrawFee, WithdrawFut,
-            WithdrawRequest, WithdrawResult, EARLY_CONFIRMATION_ERR_LOG, INVALID_CONTRACT_ADDRESS_ERR_LOG,
-            INVALID_PAYMENT_STATE_ERR_LOG, INVALID_RECEIVER_ERR_LOG, INVALID_SENDER_ERR_LOG, INVALID_SWAP_ID_ERR_LOG};
+            EthValidateFeeArgs, FeeApproxStage, FoundSwapTxSpend, GenTakerPaymentPreimageArgs, HistorySyncState,
+            IguanaPrivKey, MakerSwapTakerCoin, MarketCoinOps, MmCoin, MmCoinEnum, MyAddressError, MyWalletAddress,
+            NegotiateSwapContractAddrErr, NumConversError, NumConversResult, PaymentInstructionArgs,
+            PaymentInstructions, PaymentInstructionsErr, PrivKeyBuildPolicy, PrivKeyPolicyNotAllowed,
+            RawTransactionError, RawTransactionFut, RawTransactionRequest, RawTransactionRes, RawTransactionResult,
+            RefundError, RefundPaymentArgs, RefundResult, RewardTarget, RpcClientType, RpcTransportEventHandler,
+            RpcTransportEventHandlerShared, SearchForSwapTxSpendInput, SendMakerPaymentSpendPreimageInput,
+            SendPaymentArgs, SignEthTransactionParams, SignRawTransactionEnum, SignRawTransactionRequest,
+            SignatureError, SignatureResult, SpendPaymentArgs, SwapOps, SwapTxFeePolicy, TakerSwapMakerCoin, TradeFee,
+            TradePreimageError, TradePreimageFut, TradePreimageResult, TradePreimageValue, Transaction,
+            TransactionDetails, TransactionEnum, TransactionErr, TransactionFut, TransactionType, TxMarshalingErr,
+            UnexpectedDerivationMethod, ValidateAddressResult, ValidateFeeArgs, ValidateInstructionsErr,
+            ValidateOtherPubKeyErr, ValidatePaymentError, ValidatePaymentFut, ValidatePaymentInput, VerificationError,
+            VerificationResult, WaitForHTLCTxSpendArgs, WatcherOps, WatcherReward, WatcherRewardError,
+            WatcherSearchForSwapTxSpendInput, WatcherValidatePaymentInput, WatcherValidateTakerFeeInput,
+            WithdrawError, WithdrawFee, WithdrawFut, WithdrawRequest, WithdrawResult, EARLY_CONFIRMATION_ERR_LOG,
+            INVALID_CONTRACT_ADDRESS_ERR_LOG, INVALID_PAYMENT_STATE_ERR_LOG, INVALID_RECEIVER_ERR_LOG,
+            INVALID_SENDER_ERR_LOG, INVALID_SWAP_ID_ERR_LOG};
 pub use rlp;
 cfg_native! {
     use std::path::PathBuf;
@@ -7103,9 +7104,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 {
@@ -7115,19 +7116,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(())
     }
 
     /// Eth doesnt use multisig
-    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!()
@@ -7176,6 +7177,12 @@ impl TakerCoinSwapOpsV2 for EthCoin {
     ) -> MmResult<Self::Tx, WaitForTakerPaymentSpendError> {
         todo!()
     }
+
+    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 {

mm2src/coins/lp_coins.rs

@@ -1293,6 +1293,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
@@ -1321,8 +1323,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
@@ -1337,6 +1339,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]
@@ -1351,6 +1355,8 @@ pub struct ValidateTakerFundingArgs<'a, Coin: ParseCoinAssocTypes + ?Sized> {
     pub other_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
@@ -1459,6 +1465,8 @@ impl From<UtxoRpcError> 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
@@ -1479,6 +1487,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)) }
 }
@@ -1726,6 +1738,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]
@@ -1868,24 +1886,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>;
 
@@ -1923,6 +1941,18 @@ pub trait TakerCoinSwapOpsV2: ParseCoinAssocTypes + CommonSwapOpsV2 + Send + Syn
         from_block: u64,
         wait_until: u64,
     ) -> MmResult<Self::Tx, WaitForTakerPaymentSpendError>;
+
+    /// 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

@@ -5,7 +5,7 @@ use super::{CoinBalance, CommonSwapOpsV2, FundingTxSpend, HistorySyncState, Mark
             WaitForTakerPaymentSpendError};
 use crate::coin_errors::ValidatePaymentResult;
 use crate::{coin_errors::MyAddressError, BalanceFut, CanRefundHtlc, CheckIfMyPaymentSentArgs, CoinFutSpawner,
-            ConfirmPaymentInput, FeeApproxStage, FoundSwapTxSpend, GenPreimageResult, GenTakerFundingSpendArgs,
+            ConfirmPaymentInput, FeeApproxStage, FoundSwapTxSpend, GenPreimageResult, GenTakerPaymentPreimageArgs,
             GenTakerPaymentSpendArgs, MakerSwapTakerCoin, MmCoinEnum, NegotiateSwapContractAddrErr,
             ParseCoinAssocTypes, PaymentInstructionArgs, PaymentInstructions, PaymentInstructionsErr,
             RawTransactionResult, RefundFundingSecretArgs, RefundPaymentArgs, RefundResult, SearchForSwapTxSpendInput,
@@ -492,26 +492,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!()
@@ -555,10 +555,16 @@ impl TakerCoinSwapOpsV2 for TestCoin {
     ) -> MmResult<Self::Tx, WaitForTakerPaymentSpendError> {
         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

@@ -542,7 +542,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

@@ -1019,7 +1019,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

@@ -34,6 +34,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 {
@@ -91,8 +93,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;
@@ -243,23 +245,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 {