feat(swap): rpc to find best swap with liquidity routing for ask

mm2src/coins/eth.rs

@@ -128,6 +128,13 @@ use super::{coin_conf, lp_coinfind_or_err, AsyncMutex, BalanceError, BalanceFut,
             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};
+#[cfg(test)]
+pub(crate) use eth_utils::display_u256_with_decimal_point;
+pub use eth_utils::{addr_from_pubkey_str, addr_from_raw_pubkey, mm_number_from_u256, mm_number_to_u256,
+                    u256_to_big_decimal, wei_from_big_decimal, wei_from_coins_mm_number, wei_from_gwei_decimal,
+                    wei_to_coins_mm_number, wei_to_eth_decimal, wei_to_gwei_decimal};
+use eth_utils::{get_function_input_data, get_function_name};
+
 pub use rlp;
 cfg_native! {
     use std::path::PathBuf;
@@ -164,8 +171,12 @@ use erc20::get_token_decimals;
 pub(crate) mod eth_swap_v2;
 use eth_swap_v2::{extract_id_from_tx_data, EthPaymentType, PaymentMethod, SpendTxSearchParams};
 
+pub mod eth_utils;
 pub mod tron;
 
+pub const ETH_PROTOCOL_TYPE: &str = "ETH";
+pub const ERC20_PROTOCOL_TYPE: &str = "ERC20";
+
 /// https://github.com/artemii235/etomic-swap/blob/master/contracts/EtomicSwap.sol
 /// Dev chain (195.201.137.5:8565) contract address: 0x83965C539899cC0F918552e5A26915de40ee8852
 /// Ropsten: https://ropsten.etherscan.io/address/0x7bc1bbdd6a0a722fc9bffc49c921b685ecb84b94
@@ -6248,77 +6259,6 @@ fn validate_fee_impl(coin: EthCoin, validate_fee_args: EthValidateFeeArgs<'_>) -
     Box::new(fut.boxed().compat())
 }
 
-fn get_function_input_data(decoded: &[Token], func: &Function, index: usize) -> Result<Token, String> {
-    decoded.get(index).cloned().ok_or(format!(
-        "Missing input in function {}: No input found at index {}",
-        func.name.clone(),
-        index
-    ))
-}
-
-fn get_function_name(name: &str, watcher_reward: bool) -> String {
-    if watcher_reward {
-        format!("{}{}", name, "Reward")
-    } else {
-        name.to_owned()
-    }
-}
-
-pub fn addr_from_raw_pubkey(pubkey: &[u8]) -> Result<Address, String> {
-    let pubkey = try_s!(PublicKey::from_slice(pubkey).map_err(|e| ERRL!("{:?}", e)));
-    let eth_public = Public::from_slice(&pubkey.serialize_uncompressed()[1..65]);
-    Ok(public_to_address(&eth_public))
-}
-
-pub fn addr_from_pubkey_str(pubkey: &str) -> Result<String, String> {
-    let pubkey_bytes = try_s!(hex::decode(pubkey));
-    let addr = try_s!(addr_from_raw_pubkey(&pubkey_bytes));
-    Ok(format!("{:#02x}", addr))
-}
-
-fn display_u256_with_decimal_point(number: U256, decimals: u8) -> String {
-    let mut string = number.to_string();
-    let decimals = decimals as usize;
-    if string.len() <= decimals {
-        string.insert_str(0, &"0".repeat(decimals - string.len() + 1));
-    }
-
-    string.insert(string.len() - decimals, '.');
-    string.trim_end_matches('0').into()
-}
-
-/// Converts 'number' to value with decimal point and shifts it left by 'decimals' places
-pub fn u256_to_big_decimal(number: U256, decimals: u8) -> NumConversResult<BigDecimal> {
-    let string = display_u256_with_decimal_point(number, decimals);
-    Ok(string.parse::<BigDecimal>()?)
-}
-
-/// Shifts 'number' with decimal point right by 'decimals' places and converts it to U256 value
-pub fn wei_from_big_decimal(amount: &BigDecimal, decimals: u8) -> NumConversResult<U256> {
-    let mut amount = amount.to_string();
-    let dot = amount.find(|c| c == '.');
-    let decimals = decimals as usize;
-    if let Some(index) = dot {
-        let mut fractional = amount.split_off(index);
-        // remove the dot from fractional part
-        fractional.remove(0);
-        if fractional.len() < decimals {
-            fractional.insert_str(fractional.len(), &"0".repeat(decimals - fractional.len()));
-        }
-        fractional.truncate(decimals);
-        amount.push_str(&fractional);
-    } else {
-        amount.insert_str(amount.len(), &"0".repeat(decimals));
-    }
-    U256::from_dec_str(&amount).map_to_mm(|e| NumConversError::new(format!("{:?}", e)))
-}
-
-pub fn wei_from_gwei_decimal(bigdec: &BigDecimal) -> NumConversResult<U256> {
-    wei_from_big_decimal(bigdec, ETH_GWEI_DECIMALS)
-}
-
-pub fn wei_to_gwei_decimal(wei: U256) -> NumConversResult<BigDecimal> { u256_to_big_decimal(wei, ETH_GWEI_DECIMALS) }
-
 impl Transaction for SignedEthTx {
     fn tx_hex(&self) -> Vec<u8> { rlp::encode(self).to_vec() }
 

mm2src/coins/eth/erc20.rs

@@ -1,11 +1,13 @@
+use super::{ERC20_PROTOCOL_TYPE, ETH_PROTOCOL_TYPE};
 use crate::eth::web3_transport::Web3Transport;
 use crate::eth::{EthCoin, ERC20_CONTRACT};
-use crate::{CoinsContext, MarketCoinOps, MmCoinEnum};
+use crate::{CoinsContext, MarketCoinOps, MmCoinEnum, Ticker};
 use ethabi::Token;
 use ethereum_types::Address;
 use futures_util::TryFutureExt;
 use mm2_core::mm_ctx::MmArc;
 use mm2_err_handle::mm_error::MmResult;
+use std::str::FromStr;
 use web3::types::{BlockId, BlockNumber, CallRequest};
 use web3::{Transport, Web3};
 
@@ -70,19 +72,40 @@ pub async fn get_erc20_token_info(coin: &EthCoin, token_addr: Address) -> Result
     Ok(Erc20TokenInfo { symbol, decimals })
 }
 
+/// Finds eth platfrom coin in coins config by chain_id and returns its ticker.
+pub fn get_platform_ticker(ctx: &MmArc, chain_id: u64) -> Option<Ticker> {
+    ctx.conf["coins"].as_array()?.iter().find_map(|coin| {
+        let protocol = coin.get("protocol")?;
+        let protocol_type = protocol.get("type")?.as_str()?;
+        if protocol_type != ETH_PROTOCOL_TYPE {
+            return None;
+        }
+        let coin_chain_id = protocol.get("protocol_data")?.get("chain_id")?.as_u64()?;
+        if coin_chain_id == chain_id {
+            coin.get("coin")?.as_str().map(|s| s.to_string())
+        } else {
+            None
+        }
+    })
+}
+
 /// Finds if an ERC20 token is in coins config by its contract address and returns its ticker.
-pub fn get_erc20_ticker_by_contract_address(ctx: &MmArc, platform: &str, contract_address: &str) -> Option<String> {
+pub fn get_erc20_ticker_by_contract_address(
+    ctx: &MmArc,
+    platform_ticker: &str,
+    contract_address: &Address,
+) -> Option<String> {
     ctx.conf["coins"].as_array()?.iter().find_map(|coin| {
         let protocol = coin.get("protocol")?;
         let protocol_type = protocol.get("type")?.as_str()?;
-        if protocol_type != "ERC20" {
+        if protocol_type != ERC20_PROTOCOL_TYPE {
             return None;
         }
         let protocol_data = protocol.get("protocol_data")?;
-        let coin_platform = protocol_data.get("platform")?.as_str()?;
-        let coin_contract_address = protocol_data.get("contract_address")?.as_str()?;
+        let coin_platform_ticker = protocol_data.get("platform")?.as_str()?;
+        let coin_contract_address = Address::from_str(protocol_data.get("contract_address")?.as_str()?).ok()?;
 
-        if coin_platform == platform && coin_contract_address == contract_address {
+        if coin_platform_ticker == platform_ticker && &coin_contract_address == contract_address {
             coin.get("coin")?.as_str().map(|s| s.to_string())
         } else {
             None

mm2src/coins/eth/eth_utils.rs

@@ -0,0 +1,107 @@
+use super::{ETH_DECIMALS, ETH_GWEI_DECIMALS};
+use crate::{NumConversError, NumConversResult};
+use ethabi::{Function, Token};
+use ethereum_types::{Address, FromDecStrErr, U256};
+use ethkey::{public_to_address, Public};
+use mm2_err_handle::prelude::MapToMmResult;
+use mm2_number::{BigDecimal, MmNumber};
+use secp256k1::PublicKey;
+
+pub(crate) fn get_function_input_data(decoded: &[Token], func: &Function, index: usize) -> Result<Token, String> {
+    decoded.get(index).cloned().ok_or(format!(
+        "Missing input in function {}: No input found at index {}",
+        func.name.clone(),
+        index
+    ))
+}
+
+pub(crate) fn get_function_name(name: &str, watcher_reward: bool) -> String {
+    if watcher_reward {
+        format!("{}{}", name, "Reward")
+    } else {
+        name.to_owned()
+    }
+}
+
+pub fn addr_from_raw_pubkey(pubkey: &[u8]) -> Result<Address, String> {
+    let pubkey = try_s!(PublicKey::from_slice(pubkey).map_err(|e| ERRL!("{:?}", e)));
+    let eth_public = Public::from_slice(&pubkey.serialize_uncompressed()[1..65]);
+    Ok(public_to_address(&eth_public))
+}
+
+pub fn addr_from_pubkey_str(pubkey: &str) -> Result<String, String> {
+    let pubkey_bytes = try_s!(hex::decode(pubkey));
+    let addr = try_s!(addr_from_raw_pubkey(&pubkey_bytes));
+    Ok(format!("{:#02x}", addr))
+}
+
+pub(crate) fn display_u256_with_decimal_point(number: U256, decimals: u8) -> String {
+    let mut string = number.to_string();
+    let decimals = decimals as usize;
+    if string.len() <= decimals {
+        string.insert_str(0, &"0".repeat(decimals - string.len() + 1));
+    }
+
+    string.insert(string.len() - decimals, '.');
+    string.trim_end_matches('0').into()
+}
+
+/// Converts 'number' to value with decimal point and shifts it left by 'decimals' places
+pub fn u256_to_big_decimal(number: U256, decimals: u8) -> NumConversResult<BigDecimal> {
+    let string = display_u256_with_decimal_point(number, decimals);
+    Ok(string.parse::<BigDecimal>()?)
+}
+
+/// Shifts 'number' with decimal point right by 'decimals' places and converts it to U256 value
+pub fn wei_from_big_decimal(amount: &BigDecimal, decimals: u8) -> NumConversResult<U256> {
+    let mut amount = amount.to_string();
+    let dot = amount.find(|c| c == '.');
+    let decimals = decimals as usize;
+    if let Some(index) = dot {
+        let mut fractional = amount.split_off(index);
+        // remove the dot from fractional part
+        fractional.remove(0);
+        if fractional.len() < decimals {
+            fractional.insert_str(fractional.len(), &"0".repeat(decimals - fractional.len()));
+        }
+        fractional.truncate(decimals);
+        amount.push_str(&fractional);
+    } else {
+        amount.insert_str(amount.len(), &"0".repeat(decimals));
+    }
+    U256::from_dec_str(&amount).map_to_mm(|e| NumConversError::new(format!("{:?}", e)))
+}
+
+/// Converts BigDecimal gwei value to wei value as U256
+#[inline(always)]
+pub fn wei_from_gwei_decimal(bigdec: &BigDecimal) -> NumConversResult<U256> {
+    wei_from_big_decimal(bigdec, ETH_GWEI_DECIMALS)
+}
+
+/// Converts a U256 wei value to an gwei value as a BigDecimal
+#[inline(always)]
+pub fn wei_to_gwei_decimal(wei: U256) -> NumConversResult<BigDecimal> { u256_to_big_decimal(wei, ETH_GWEI_DECIMALS) }
+
+/// Converts a U256 wei value to an ETH value as a BigDecimal
+/// TODO: use wei_to_eth_decimal instead of u256_to_big_decimal(gas_cost_wei, ETH_DECIMALS)
+#[inline(always)]
+pub fn wei_to_eth_decimal(wei: U256) -> NumConversResult<BigDecimal> { u256_to_big_decimal(wei, ETH_DECIMALS) }
+
+#[inline]
+pub fn mm_number_to_u256(mm_number: &MmNumber) -> Result<U256, FromDecStrErr> {
+    U256::from_dec_str(mm_number.to_ratio().to_integer().to_string().as_str())
+}
+
+#[inline]
+pub fn mm_number_from_u256(u256: U256) -> MmNumber { MmNumber::from(u256.to_string().as_str()) }
+
+#[inline]
+pub fn wei_from_coins_mm_number(mm_number: &MmNumber, decimals: u8) -> NumConversResult<U256> {
+    wei_from_big_decimal(&mm_number.to_decimal(), decimals)
+}
+
+#[inline]
+#[allow(unused)]
+pub fn wei_to_coins_mm_number(u256: U256, decimals: u8) -> NumConversResult<MmNumber> {
+    Ok(MmNumber::from(u256_to_big_decimal(u256, decimals)?))
+}

mm2src/coins/lp_coins.rs

@@ -52,7 +52,7 @@ use crypto::{derive_secp256k1_secret, Bip32Error, Bip44Chain, CryptoCtx, CryptoC
              Secp256k1ExtendedPublicKey, Secp256k1Secret, WithHwRpcError};
 use derive_more::Display;
 use enum_derives::{EnumFromStringify, EnumFromTrait};
-use ethereum_types::{H256, H264, H520, U256};
+use ethereum_types::{Address as EthAddress, H256, H264, H520, U256};
 use futures::compat::Future01CompatExt;
 use futures::lock::{Mutex as AsyncMutex, MutexGuard as AsyncMutexGuard};
 use futures::{FutureExt, TryFutureExt};
@@ -309,6 +309,7 @@ pub type ValidateTakerFundingSpendPreimageResult = MmResult<(), ValidateTakerFun
 pub type ValidateTakerPaymentSpendPreimageResult = MmResult<(), ValidateTakerPaymentSpendPreimageError>;
 
 pub type IguanaPrivKey = Secp256k1Secret;
+pub type Ticker = String;
 
 // Constants for logs used in tests
 pub const INVALID_SENDER_ERR_LOG: &str = "Invalid sender";
@@ -4590,18 +4591,26 @@ pub enum CustomTokenError {
         fmt = "Token with the same ticker already exists in coins configs, ticker in config: {}",
         ticker_in_config
     )]
-    DuplicateTickerInConfig { ticker_in_config: String },
+    DuplicateTickerInConfig {
+        ticker_in_config: String,
+    },
     #[display(
         fmt = "Token with the same contract address already exists in coins configs, ticker in config: {}",
         ticker_in_config
     )]
-    DuplicateContractInConfig { ticker_in_config: String },
+    DuplicateContractInConfig {
+        ticker_in_config: String,
+    },
     #[display(
         fmt = "Token is already activated, ticker: {}, contract address: {}",
         ticker,
         contract_address
     )]
-    TokenWithSameContractAlreadyActivated { ticker: String, contract_address: String },
+    TokenWithSameContractAlreadyActivated {
+        ticker: String,
+        contract_address: String,
+    },
+    InvalidTokenAddress,
 }
 
 impl CoinProtocol {
@@ -4667,7 +4676,11 @@ impl CoinProtocol {
         // if it is duplicated in config, we will have two orderbooks one using the ticker and one using the contract address.
         // Todo: We should use the contract address for orderbook topics instead of the ticker once we make custom tokens non-wallet only.
         // If a coin is added to the config later, users who added it as a custom token and did not update will not see the orderbook.
-        if let Some(existing_ticker) = get_erc20_ticker_by_contract_address(ctx, platform, contract_address) {
+        if let Some(existing_ticker) = get_erc20_ticker_by_contract_address(
+            ctx,
+            platform,
+            &EthAddress::from_str(contract_address).map_err(|_| MmError::new(CustomTokenError::InvalidTokenAddress))?,
+        ) {
             return Err(MmError::new(CustomTokenError::DuplicateContractInConfig {
                 ticker_in_config: existing_ticker,
             }));

mm2src/coins_activation/src/erc20_token_activation.rs

@@ -72,6 +72,7 @@ impl TryFromCoinProtocol for Erc20Protocol {
                 contract_address,
             } => {
                 let token_addr = valid_addr_from_str(&contract_address).map_err(|_| CoinProtocol::ERC20 {
+                    // TODO: maybe add error description to this err (we're losing 'Invalid address checksum' here)
                     platform: platform.clone(),
                     contract_address,
                 })?;

mm2src/mm2_main/Cargo.toml

@@ -135,6 +135,7 @@ coins_activation = { path = "../coins_activation", features = ["for-tests"] }
 common = { path = "../common", features = ["for-tests"] }
 mm2_test_helpers = { path = "../mm2_test_helpers" }
 trading_api = { path = "../trading_api", features = ["for-tests"] }
+env_logger.workspace = true
 mocktopus.workspace = true
 testcontainers.workspace = true
 web3 = { workspace = true, default-features = false, features = ["http-rustls-tls"] }