[r2r] Mm2 error refactoring

mm2src/coins/coin_errors.rs

@@ -0,0 +1,85 @@
+use crate::{my_tx_history_v2::MyTxHistoryErrorV2, utxo::rpc_clients::UtxoRpcError, DelegationError, NumConversError,
+            TxHistoryError, UnexpectedDerivationMethod, WithdrawError};
+use futures01::Future;
+use mm2_err_handle::prelude::MmError;
+use spv_validation::helpers_validation::SPVError;
+
+pub type ValidatePaymentFut<T> = Box<dyn Future<Item = T, Error = MmError<ValidatePaymentError>> + Send>;
+
+#[derive(Debug, Display)]
+pub enum ValidatePaymentError {
+    InternalError(String),
+    // Problem with deserializing the transaction, or one of the transaction parts is invalid.
+    TxDeserializationError(String),
+    InvalidInput(String),
+    InvalidRpcResponse(String),
+    SPVError(SPVError),
+    UnexpectedPaymentState(String),
+    Transport(String),
+    // Transaction has wrong properties, for example, it has been sent to a wrong address
+    WrongPaymentTx(String),
+}
+
+impl From<rlp::DecoderError> for ValidatePaymentError {
+    fn from(err: rlp::DecoderError) -> Self { Self::TxDeserializationError(err.to_string()) }
+}
+
+impl From<web3::Error> for ValidatePaymentError {
+    fn from(err: web3::Error) -> Self { Self::Transport(err.to_string()) }
+}
+
+impl From<NumConversError> for ValidatePaymentError {
+    fn from(err: NumConversError) -> Self { Self::InternalError(err.to_string()) }
+}
+
+impl From<SPVError> for ValidatePaymentError {
+    fn from(err: SPVError) -> Self { Self::SPVError(err) }
+}
+
+impl From<serialization::Error> for ValidatePaymentError {
+    fn from(err: serialization::Error) -> Self { Self::TxDeserializationError(err.to_string()) }
+}
+
+impl From<UnexpectedDerivationMethod> for ValidatePaymentError {
+    fn from(err: UnexpectedDerivationMethod) -> Self { Self::InternalError(err.to_string()) }
+}
+
+impl From<UtxoRpcError> for ValidatePaymentError {
+    fn from(err: UtxoRpcError) -> Self {
+        match err {
+            UtxoRpcError::Transport(e) => Self::Transport(e.to_string()),
+            UtxoRpcError::Internal(e) => Self::InternalError(e),
+            _ => Self::InvalidRpcResponse(err.to_string()),
+        }
+    }
+}
+
+#[derive(Debug, Display)]
+pub enum MyAddressError {
+    UnexpectedDerivationMethod(String),
+    InternalError(String),
+}
+
+impl From<UnexpectedDerivationMethod> for MyAddressError {
+    fn from(err: UnexpectedDerivationMethod) -> Self { Self::UnexpectedDerivationMethod(err.to_string()) }
+}
+
+impl From<MyAddressError> for WithdrawError {
+    fn from(err: MyAddressError) -> Self { Self::InternalError(err.to_string()) }
+}
+
+impl From<MyAddressError> for UtxoRpcError {
+    fn from(err: MyAddressError) -> Self { Self::Internal(err.to_string()) }
+}
+
+impl From<MyAddressError> for DelegationError {
+    fn from(err: MyAddressError) -> Self { Self::InternalError(err.to_string()) }
+}
+
+impl From<MyAddressError> for TxHistoryError {
+    fn from(err: MyAddressError) -> Self { Self::InternalError(err.to_string()) }
+}
+
+impl From<MyAddressError> for MyTxHistoryErrorV2 {
+    fn from(err: MyAddressError) -> Self { Self::Internal(err.to_string()) }
+}

mm2src/coins/eth.rs

@@ -60,15 +60,15 @@ use web3::{self, Web3};
 use web3_transport::{EthFeeHistoryNamespace, Web3Transport, Web3TransportNode};
 
 use super::{coin_conf, AsyncMutex, BalanceError, BalanceFut, CoinBalance, CoinProtocol, CoinTransportMetrics,
-            CoinsContext, FeeApproxStage, FoundSwapTxSpend, HistorySyncState, MarketCoinOps, MmCoin,
+            CoinsContext, FeeApproxStage, FoundSwapTxSpend, HistorySyncState, MarketCoinOps, MmCoin, MyAddressError,
             NegotiateSwapContractAddrErr, NumConversError, NumConversResult, RawTransactionError, RawTransactionFut,
             RawTransactionRequest, RawTransactionRes, RawTransactionResult, RpcClientType, RpcTransportEventHandler,
             RpcTransportEventHandlerShared, SearchForSwapTxSpendInput, SignatureError, SignatureResult, SwapOps,
             TradeFee, TradePreimageError, TradePreimageFut, TradePreimageResult, TradePreimageValue, Transaction,
             TransactionDetails, TransactionEnum, TransactionErr, TransactionFut, TxMarshalingErr,
-            UnexpectedDerivationMethod, ValidateAddressResult, ValidatePaymentInput, VerificationError,
-            VerificationResult, WatcherValidatePaymentInput, WithdrawError, WithdrawFee, WithdrawFut, WithdrawRequest,
-            WithdrawResult};
+            UnexpectedDerivationMethod, ValidateAddressResult, ValidatePaymentError, ValidatePaymentFut,
+            ValidatePaymentInput, VerificationError, VerificationResult, WatcherValidatePaymentInput, WithdrawError,
+            WithdrawFee, WithdrawFut, WithdrawRequest, WithdrawResult};
 
 pub use rlp;
 
@@ -685,7 +685,7 @@ async fn withdraw_impl(coin: EthCoin, req: WithdrawRequest) -> WithdrawResult {
     if coin.coin_type == EthCoinType::Eth {
         spent_by_me += &fee_details.total_fee;
     }
-    let my_address = coin.my_address().map_to_mm(WithdrawError::InternalError)?;
+    let my_address = coin.my_address()?;
     Ok(TransactionDetails {
         to: vec![checksum_address(&format!("{:#02x}", to_addr))],
         from: vec![my_address],
@@ -970,8 +970,11 @@ impl SwapOps for EthCoin {
         Box::new(fut.boxed().compat())
     }
 
-    fn validate_maker_payment(&self, input: ValidatePaymentInput) -> Box<dyn Future<Item = (), Error = String> + Send> {
-        let swap_contract_address = try_fus!(input.swap_contract_address.try_to_address());
+    fn validate_maker_payment(&self, input: ValidatePaymentInput) -> ValidatePaymentFut<()> {
+        let swap_contract_address = try_f!(input
+            .swap_contract_address
+            .try_to_address()
+            .map_to_mm(ValidatePaymentError::InvalidInput));
         self.validate_payment(
             &input.payment_tx,
             input.time_lock,
@@ -982,8 +985,11 @@ impl SwapOps for EthCoin {
         )
     }
 
-    fn validate_taker_payment(&self, input: ValidatePaymentInput) -> Box<dyn Future<Item = (), Error = String> + Send> {
-        let swap_contract_address = try_fus!(input.swap_contract_address.try_to_address());
+    fn validate_taker_payment(&self, input: ValidatePaymentInput) -> ValidatePaymentFut<()> {
+        let swap_contract_address = try_f!(input
+            .swap_contract_address
+            .try_to_address()
+            .map_to_mm(ValidatePaymentError::InvalidInput));
         self.validate_payment(
             &input.payment_tx,
             input.time_lock,
@@ -997,7 +1003,7 @@ impl SwapOps for EthCoin {
     fn watcher_validate_taker_payment(
         &self,
         _input: WatcherValidatePaymentInput,
-    ) -> Box<dyn Future<Item = (), Error = String> + Send> {
+    ) -> Box<dyn Future<Item = (), Error = MmError<ValidatePaymentError>> + Send> {
         unimplemented!();
     }
 
@@ -1140,7 +1146,9 @@ impl SwapOps for EthCoin {
 impl MarketCoinOps for EthCoin {
     fn ticker(&self) -> &str { &self.ticker[..] }
 
-    fn my_address(&self) -> Result<String, String> { Ok(checksum_address(&format!("{:#02x}", self.my_address))) }
+    fn my_address(&self) -> MmResult<String, MyAddressError> {
+        Ok(checksum_address(&format!("{:#02x}", self.my_address)))
+    }
 
     fn get_public_key(&self) -> Result<String, MmError<UnexpectedDerivationMethod>> {
         let uncompressed_without_prefix = hex::encode(self.key_pair.public());
@@ -2693,150 +2701,167 @@ impl EthCoin {
         secret_hash: &[u8],
         amount: BigDecimal,
         expected_swap_contract_address: Address,
-    ) -> Box<dyn Future<Item = (), Error = String> + Send> {
-        let unsigned: UnverifiedTransaction = try_fus!(rlp::decode(payment_tx));
-        let tx = try_fus!(SignedEthTx::new(unsigned));
-        let sender = try_fus!(addr_from_raw_pubkey(sender_pub));
-        let expected_value = try_fus!(wei_from_big_decimal(&amount, self.decimals));
+    ) -> ValidatePaymentFut<()> {
+        let unsigned: UnverifiedTransaction = try_f!(rlp::decode(payment_tx));
+        let tx =
+            try_f!(SignedEthTx::new(unsigned)
+                .map_to_mm(|err| ValidatePaymentError::TxDeserializationError(err.to_string())));
+        let sender = try_f!(addr_from_raw_pubkey(sender_pub).map_to_mm(ValidatePaymentError::InvalidInput));
+        let expected_value = try_f!(wei_from_big_decimal(&amount, self.decimals));
         let selfi = self.clone();
         let secret_hash = secret_hash.to_vec();
         let fut = async move {
             let swap_id = selfi.etomic_swap_id(time_lock, &secret_hash);
-            let status = try_s!(
-                selfi
-                    .payment_status(expected_swap_contract_address, Token::FixedBytes(swap_id.clone()))
-                    .compat()
-                    .await
-            );
+            let status = selfi
+                .payment_status(expected_swap_contract_address, Token::FixedBytes(swap_id.clone()))
+                .compat()
+                .await
+                .map_to_mm(ValidatePaymentError::Transport)?;
             if status != PAYMENT_STATE_SENT.into() {
-                return ERR!("Payment state is not PAYMENT_STATE_SENT, got {}", status);
+                return MmError::err(ValidatePaymentError::UnexpectedPaymentState(format!(
+                    "Payment state is not PAYMENT_STATE_SENT, got {}",
+                    status
+                )));
             }
 
-            let tx_from_rpc = try_s!(
-                selfi
-                    .web3
-                    .eth()
-                    .transaction(TransactionId::Hash(tx.hash))
-                    .compat()
-                    .await
-            );
+            let tx_from_rpc = selfi
+                .web3
+                .eth()
+                .transaction(TransactionId::Hash(tx.hash))
+                .compat()
+                .await?;
             let tx_from_rpc = match tx_from_rpc {
                 Some(t) => t,
-                None => return ERR!("Didn't find provided tx {:?} on ETH node", tx),
+                None => {
+                    return MmError::err(ValidatePaymentError::UnexpectedPaymentState(format!(
+                        "Didn't find provided tx {:?} on ETH node",
+                        tx
+                    )))
+                },
             };
 
             if tx_from_rpc.from != sender {
-                return ERR!(
+                return MmError::err(ValidatePaymentError::WrongPaymentTx(format!(
                     "Payment tx {:?} was sent from wrong address, expected {:?}",
-                    tx_from_rpc,
-                    sender
-                );
+                    tx_from_rpc, sender
+                )));
             }
 
             match &selfi.coin_type {
                 EthCoinType::Eth => {
                     if tx_from_rpc.to != Some(expected_swap_contract_address) {
-                        return ERR!(
+                        return MmError::err(ValidatePaymentError::WrongPaymentTx(format!(
                             "Payment tx {:?} was sent to wrong address, expected {:?}",
-                            tx_from_rpc,
-                            expected_swap_contract_address
-                        );
+                            tx_from_rpc, expected_swap_contract_address,
+                        )));
                     }
 
                     if tx_from_rpc.value != expected_value {
-                        return ERR!(
-                            "Payment tx {:?} value is invalid, expected {:?}",
-                            tx_from_rpc,
-                            expected_value
-                        );
+                        return MmError::err(ValidatePaymentError::WrongPaymentTx(format!(
+                            "Payment tx value arg {:?} is invalid, expected {:?}",
+                            tx_from_rpc, expected_value
+                        )));
                     }
 
-                    let function = try_s!(SWAP_CONTRACT.function("ethPayment"));
-                    let decoded = try_s!(function.decode_input(&tx_from_rpc.input.0));
+                    let function = SWAP_CONTRACT
+                        .function("ethPayment")
+                        .map_to_mm(|err| ValidatePaymentError::InternalError(err.to_string()))?;
+                    let decoded = function
+                        .decode_input(&tx_from_rpc.input.0)
+                        .map_to_mm(|err| ValidatePaymentError::TxDeserializationError(err.to_string()))?;
                     if decoded[0] != Token::FixedBytes(swap_id.clone()) {
-                        return ERR!("Invalid 'swap_id' {:?}, expected {:?}", decoded, swap_id);
+                        return MmError::err(ValidatePaymentError::WrongPaymentTx(format!(
+                            "Invalid 'swap_id' {:?}, expected {:?}",
+                            decoded, swap_id
+                        )));
                     }
 
                     if decoded[1] != Token::Address(selfi.my_address) {
-                        return ERR!(
+                        return MmError::err(ValidatePaymentError::WrongPaymentTx(format!(
                             "Payment tx receiver arg {:?} is invalid, expected {:?}",
                             decoded[1],
                             Token::Address(selfi.my_address)
-                        );
+                        )));
                     }
 
                     if decoded[2] != Token::FixedBytes(secret_hash.to_vec()) {
-                        return ERR!(
+                        return MmError::err(ValidatePaymentError::WrongPaymentTx(format!(
                             "Payment tx secret_hash arg {:?} is invalid, expected {:?}",
                             decoded[2],
-                            Token::FixedBytes(secret_hash.to_vec())
-                        );
+                            Token::FixedBytes(secret_hash.to_vec()),
+                        )));
                     }
 
                     if decoded[3] != Token::Uint(U256::from(time_lock)) {
-                        return ERR!(
+                        return MmError::err(ValidatePaymentError::WrongPaymentTx(format!(
                             "Payment tx time_lock arg {:?} is invalid, expected {:?}",
                             decoded[3],
-                            Token::Uint(U256::from(time_lock))
-                        );
+                            Token::Uint(U256::from(time_lock)),
+                        )));
                     }
                 },
                 EthCoinType::Erc20 {
                     platform: _,
                     token_addr,
                 } => {
                     if tx_from_rpc.to != Some(expected_swap_contract_address) {
-                        return ERR!(
+                        return MmError::err(ValidatePaymentError::WrongPaymentTx(format!(
                             "Payment tx {:?} was sent to wrong address, expected {:?}",
-                            tx_from_rpc,
-                            expected_swap_contract_address
-                        );
+                            tx_from_rpc, expected_swap_contract_address,
+                        )));
                     }
 
-                    let function = try_s!(SWAP_CONTRACT.function("erc20Payment"));
-                    let decoded = try_s!(function.decode_input(&tx_from_rpc.input.0));
+                    let function = SWAP_CONTRACT
+                        .function("erc20Payment")
+                        .map_to_mm(|err| ValidatePaymentError::InternalError(err.to_string()))?;
+                    let decoded = function
+                        .decode_input(&tx_from_rpc.input.0)
+                        .map_to_mm(|err| ValidatePaymentError::TxDeserializationError(err.to_string()))?;
                     if decoded[0] != Token::FixedBytes(swap_id.clone()) {
-                        return ERR!("Invalid 'swap_id' {:?}, expected {:?}", decoded, swap_id);
+                        return MmError::err(ValidatePaymentError::WrongPaymentTx(format!(
+                            "Invalid 'swap_id' {:?}, expected {:?}",
+                            decoded, swap_id
+                        )));
                     }
 
                     if decoded[1] != Token::Uint(expected_value) {
-                        return ERR!(
+                        return MmError::err(ValidatePaymentError::WrongPaymentTx(format!(
                             "Payment tx value arg {:?} is invalid, expected {:?}",
                             decoded[1],
-                            Token::Uint(expected_value)
-                        );
+                            Token::Uint(expected_value),
+                        )));
                     }
 
                     if decoded[2] != Token::Address(*token_addr) {
-                        return ERR!(
+                        return MmError::err(ValidatePaymentError::WrongPaymentTx(format!(
                             "Payment tx token_addr arg {:?} is invalid, expected {:?}",
                             decoded[2],
                             Token::Address(*token_addr)
-                        );
+                        )));
                     }
 
                     if decoded[3] != Token::Address(selfi.my_address) {
-                        return ERR!(
+                        return MmError::err(ValidatePaymentError::WrongPaymentTx(format!(
                             "Payment tx receiver arg {:?} is invalid, expected {:?}",
                             decoded[3],
-                            Token::Address(selfi.my_address)
-                        );
+                            Token::Address(selfi.my_address),
+                        )));
                     }
 
                     if decoded[4] != Token::FixedBytes(secret_hash.to_vec()) {
-                        return ERR!(
+                        return MmError::err(ValidatePaymentError::WrongPaymentTx(format!(
                             "Payment tx secret_hash arg {:?} is invalid, expected {:?}",
                             decoded[4],
-                            Token::FixedBytes(secret_hash.to_vec())
-                        );
+                            Token::FixedBytes(secret_hash.to_vec()),
+                        )));
                     }
 
                     if decoded[5] != Token::Uint(U256::from(time_lock)) {
-                        return ERR!(
+                        return MmError::err(ValidatePaymentError::WrongPaymentTx(format!(
                             "Payment tx time_lock arg {:?} is invalid, expected {:?}",
                             decoded[5],
-                            Token::Uint(U256::from(time_lock))
-                        );
+                            Token::Uint(U256::from(time_lock)),
+                        )));
                     }
                 },
             }