[r2r] tendermint missing implementations

mm2src/coins/eth.rs

@@ -3258,7 +3258,7 @@ impl MmCoin for EthCoin {
         })
     }
 
-    fn get_receiver_trade_fee(&self, stage: FeeApproxStage) -> TradePreimageFut<TradeFee> {
+    fn get_receiver_trade_fee(&self, _send_amount: BigDecimal, stage: FeeApproxStage) -> TradePreimageFut<TradeFee> {
         let coin = self.clone();
         let fut = async move {
             let gas_price = coin.get_gas_price().compat().await?;

mm2src/coins/eth/eth_tests.rs

@@ -932,7 +932,7 @@ fn get_receiver_trade_preimage() {
     };
 
     let actual = coin
-        .get_receiver_trade_fee(FeeApproxStage::WithoutApprox)
+        .get_receiver_trade_fee(Default::default(), FeeApproxStage::WithoutApprox)
         .wait()
         .expect("!get_sender_trade_fee");
     assert_eq!(actual, expected_fee);

mm2src/coins/lightning.rs

@@ -1056,7 +1056,7 @@ impl MmCoin for LightningCoin {
     }
 
     // Todo: This uses dummy data for now for the sake of swap P.O.C., this should be implemented probably after agreeing on how fees will work for lightning
-    fn get_receiver_trade_fee(&self, _stage: FeeApproxStage) -> TradePreimageFut<TradeFee> {
+    fn get_receiver_trade_fee(&self, _send_amount: BigDecimal, _stage: FeeApproxStage) -> TradePreimageFut<TradeFee> {
         Box::new(futures01::future::ok(TradeFee {
             coin: self.ticker().to_owned(),
             amount: Default::default(),

mm2src/coins/lp_coins.rs

@@ -1042,6 +1042,7 @@ pub enum TransactionType {
     RemoveDelegation,
     StandardTransfer,
     TokenTransfer(BytesJson),
+    Fee(BytesJson),
 }
 
 impl Default for TransactionType {
@@ -1908,7 +1909,7 @@ pub trait MmCoin: SwapOps + WatcherOps + MarketCoinOps + Send + Sync + 'static {
     ) -> TradePreimageResult<TradeFee>;
 
     /// Get fee to be paid by receiver per whole swap and check if the wallet has sufficient balance to pay the fee.
-    fn get_receiver_trade_fee(&self, stage: FeeApproxStage) -> TradePreimageFut<TradeFee>;
+    fn get_receiver_trade_fee(&self, send_amount: BigDecimal, stage: FeeApproxStage) -> TradePreimageFut<TradeFee>;
 
     /// Get transaction fee the Taker has to pay to send a `TakerFee` transaction and check if the wallet has sufficient balance to pay the fee.
     async fn get_fee_to_send_taker_fee(

mm2src/coins/my_tx_history_v2.rs

@@ -1,8 +1,10 @@
 use crate::hd_wallet::{AddressDerivingError, InvalidBip44ChainError};
+use crate::tendermint::{TENDERMINT_ASSET_PROTOCOL_TYPE, TENDERMINT_COIN_PROTOCOL_TYPE};
 use crate::tx_history_storage::{CreateTxHistoryStorageError, FilteringAddresses, GetTxHistoryFilters,
                                 TxHistoryStorageBuilder, WalletId};
-use crate::{lp_coinfind_or_err, BlockHeightAndTime, CoinFindError, HDAccountAddressId, HistorySyncState, MmCoin,
-            MmCoinEnum, Transaction, TransactionDetails, TransactionType, TxFeeDetails, UtxoRpcError};
+use crate::utxo::utxo_common::big_decimal_from_sat_unsigned;
+use crate::{coin_conf, lp_coinfind_or_err, BlockHeightAndTime, CoinFindError, HDAccountAddressId, HistorySyncState,
+            MmCoin, MmCoinEnum, Transaction, TransactionDetails, TransactionType, TxFeeDetails, UtxoRpcError};
 use async_trait::async_trait;
 use bitcrypto::sha256;
 use common::{calc_total_pages, ten, HttpStatusCode, PagingOptionsEnum, StatusCode};
@@ -13,8 +15,10 @@ use keys::{Address, CashAddress};
 use mm2_core::mm_ctx::MmArc;
 use mm2_err_handle::prelude::*;
 use mm2_number::BigDecimal;
+use num_traits::ToPrimitive;
 use rpc::v1::types::{Bytes as BytesJson, ToTxHash};
 use std::collections::HashSet;
+use std::mem::discriminant;
 
 #[derive(Debug)]
 pub enum RemoveTxResult {
@@ -69,6 +73,9 @@ pub trait TxHistoryStorage: Send + Sync + 'static {
         internal_id: &BytesJson,
     ) -> Result<Option<TransactionDetails>, MmError<Self::Error>>;
 
+    /// Gets the highest block_height from the selected wallet's history
+    async fn get_highest_block_height(&self, wallet_id: &WalletId) -> Result<Option<u32>, MmError<Self::Error>>;
+
     /// Returns whether the history contains unconfirmed transactions.
     async fn history_contains_unconfirmed_txes(
         &self,
@@ -210,7 +217,7 @@ impl<'a, Addr: Clone + DisplayAddress + Eq + std::hash::Hash, Tx: Transaction> T
 
         let tx_hash = self.tx.tx_hash();
         let internal_id = match &self.transaction_type {
-            TransactionType::TokenTransfer(token_id) => {
+            TransactionType::TokenTransfer(token_id) | TransactionType::Fee(token_id) => {
                 let mut bytes_for_hash = tx_hash.0.clone();
                 bytes_for_hash.extend_from_slice(&token_id.0);
                 sha256(&bytes_for_hash).to_vec().into()
@@ -375,6 +382,8 @@ pub async fn my_tx_history_v2_rpc(
         MmCoinEnum::SlpToken(slp_token) => my_tx_history_v2_impl(ctx, &slp_token, request).await,
         MmCoinEnum::UtxoCoin(utxo) => my_tx_history_v2_impl(ctx, &utxo, request).await,
         MmCoinEnum::QtumCoin(qtum) => my_tx_history_v2_impl(ctx, &qtum, request).await,
+        MmCoinEnum::Tendermint(tendermint) => my_tx_history_v2_impl(ctx, &tendermint, request).await,
+        MmCoinEnum::TendermintToken(tendermint_token) => my_tx_history_v2_impl(ctx, &tendermint_token, request).await,
         other => MmError::err(MyTxHistoryErrorV2::NotSupportedFor(other.ticker().to_owned())),
     }
 }
@@ -406,22 +415,62 @@ where
         .get_history(&wallet_id, filters, request.paging_options.clone(), request.limit)
         .await?;
 
-    let transactions = history
-        .transactions
-        .into_iter()
-        .map(|mut details| {
-            // it can be the platform ticker instead of the token ticker for a pre-saved record
-            if details.coin != request.coin {
-                details.coin = request.coin.clone();
-            }
-            let confirmations = if details.block_height == 0 || details.block_height > current_block {
-                0
-            } else {
-                current_block + 1 - details.block_height
-            };
-            MyTxHistoryDetails { confirmations, details }
-        })
-        .collect();
+    let coin_conf = coin_conf(&ctx, coin.ticker());
+    let protocol_type = coin_conf["protocol"]["type"].as_str().unwrap_or_default();
+    let decimals = coin.decimals();
+
+    let transactions =
+        history
+            .transactions
+            .into_iter()
+            .map(|mut details| {
+                // checking if transaction type is not `Fee`
+                if discriminant(&details.transaction_type) != discriminant(&TransactionType::Fee(BytesJson::default()))
+                {
+                    // it can be the platform ticker instead of the token ticker for a pre-saved record
+                    if details.coin != request.coin {
+                        details.coin = request.coin.clone();
+                    }
+
+                    match protocol_type {
+                        // for tendermint, tx_history_v2 implementation doesn't include amount parsing logic.
+                        // therefore, re-mapping is required
+                        TENDERMINT_COIN_PROTOCOL_TYPE | TENDERMINT_ASSET_PROTOCOL_TYPE => {
+                            // In order to use error result instead of panicking, we should do an extra iteration above this map.
+                            // Because all the values are inserted by u64 convertion in tx_history_v2 implementation, using `panic`
+                            // shouldn't harm.
+
+                            let u_total_amount = details.total_amount.to_u64().unwrap_or_else(|| {
+                                panic!("Parsing '{}' into u64 should not fail", details.total_amount)
+                            });
+                            details.total_amount = big_decimal_from_sat_unsigned(u_total_amount, decimals);
+
+                            let u_spent_by_me = details.spent_by_me.to_u64().unwrap_or_else(|| {
+                                panic!("Parsing '{}' into u64 should not fail", details.spent_by_me)
+                            });
+                            details.spent_by_me = big_decimal_from_sat_unsigned(u_spent_by_me, decimals);
+
+                            let u_received_by_me = details.received_by_me.to_u64().unwrap_or_else(|| {
+                                panic!("Parsing '{}' into u64 should not fail", details.received_by_me)
+                            });
+                            details.received_by_me = big_decimal_from_sat_unsigned(u_received_by_me, decimals);
+
+                            // Because this can be negative values, no need to read and parse
+                            // this since it's always 0 from tx_history_v2 implementation.
+                            details.my_balance_change = &details.received_by_me - &details.spent_by_me;
+                        },
+                        _ => {},
+                    };
+                }
+
+                let confirmations = if details.block_height == 0 || details.block_height > current_block {
+                    0
+                } else {
+                    current_block + 1 - details.block_height
+                };
+                MyTxHistoryDetails { confirmations, details }
+            })
+            .collect();
 
     Ok(MyTxHistoryResponseV2 {
         coin: request.coin,

mm2src/coins/qrc20.rs

@@ -1316,7 +1316,7 @@ impl MmCoin for Qrc20Coin {
         })
     }
 
-    fn get_receiver_trade_fee(&self, stage: FeeApproxStage) -> TradePreimageFut<TradeFee> {
+    fn get_receiver_trade_fee(&self, _send_amount: BigDecimal, stage: FeeApproxStage) -> TradePreimageFut<TradeFee> {
         let selfi = self.clone();
         let fut = async move {
             // pass the dummy params

mm2src/coins/qrc20/qrc20_tests.rs

@@ -876,7 +876,7 @@ fn test_receiver_trade_preimage() {
     check_tx_fee(&coin, ActualTxFee::FixedPerKb(EXPECTED_TX_FEE as u64));
 
     let actual = coin
-        .get_receiver_trade_fee(FeeApproxStage::WithoutApprox)
+        .get_receiver_trade_fee(Default::default(), FeeApproxStage::WithoutApprox)
         .wait()
         .expect("!get_receiver_trade_fee");
     // only one contract call should be included into the expected trade fee

mm2src/coins/solana.rs

@@ -672,18 +672,20 @@ impl MmCoin for SolanaCoin {
 
     async fn get_sender_trade_fee(
         &self,
-        value: TradePreimageValue,
-        stage: FeeApproxStage,
+        _value: TradePreimageValue,
+        _stage: FeeApproxStage,
     ) -> TradePreimageResult<TradeFee> {
         unimplemented!()
     }
 
-    fn get_receiver_trade_fee(&self, _stage: FeeApproxStage) -> TradePreimageFut<TradeFee> { unimplemented!() }
+    fn get_receiver_trade_fee(&self, _send_amount: BigDecimal, _stage: FeeApproxStage) -> TradePreimageFut<TradeFee> {
+        unimplemented!()
+    }
 
     async fn get_fee_to_send_taker_fee(
         &self,
-        dex_fee_amount: BigDecimal,
-        stage: FeeApproxStage,
+        _dex_fee_amount: BigDecimal,
+        _stage: FeeApproxStage,
     ) -> TradePreimageResult<TradeFee> {
         unimplemented!()
     }

mm2src/coins/solana/spl.rs

@@ -474,7 +474,9 @@ impl MmCoin for SplToken {
         unimplemented!()
     }
 
-    fn get_receiver_trade_fee(&self, _stage: FeeApproxStage) -> TradePreimageFut<TradeFee> { unimplemented!() }
+    fn get_receiver_trade_fee(&self, _send_amount: BigDecimal, _stage: FeeApproxStage) -> TradePreimageFut<TradeFee> {
+        unimplemented!()
+    }
 
     async fn get_fee_to_send_taker_fee(
         &self,

mm2src/coins/tendermint/iris/htlc.rs

@@ -21,6 +21,8 @@
 // check this page https://www.irisnet.org/docs/get-started/testnet.html#faucet
 
 use super::htlc_proto::{ClaimHtlcProtoRep, CreateHtlcProtoRep};
+
+use crate::tendermint::type_urls::{CLAIM_HTLC_TYPE_URL, CREATE_HTLC_TYPE_URL};
 use cosmrs::{tx::{Msg, MsgProto},
              AccountId, Coin, ErrorReport};
 use std::convert::TryFrom;
@@ -30,9 +32,6 @@ pub const HTLC_STATE_OPEN: i32 = 0;
 pub const HTLC_STATE_COMPLETED: i32 = 1;
 pub const HTLC_STATE_REFUNDED: i32 = 2;
 
-const CREATE_HTLC_TYPE_URL: &str = "/irismod.htlc.MsgCreateHTLC";
-const CLAIM_HTLC_TYPE_URL: &str = "/irismod.htlc.MsgClaimHTLC";
-
 #[allow(dead_code)]
 pub(crate) struct IrisHtlc {
     /// Generated HTLC's ID.

mm2src/coins/tendermint/iris/htlc_proto.rs

@@ -38,14 +38,14 @@ pub(crate) struct QueryHtlcRequestProto {
 
 #[derive(prost::Enumeration, Debug)]
 #[repr(i32)]
-pub(crate) enum HtlcState {
+pub enum HtlcState {
     Open = 0,
     Completed = 1,
     Refunded = 2,
 }
 
 #[derive(prost::Message)]
-pub(crate) struct HtlcProto {
+pub struct HtlcProto {
     #[prost(string, tag = "1")]
     pub(crate) id: prost::alloc::string::String,
     #[prost(string, tag = "2")]

mm2src/coins/tendermint/iris/mod.rs

@@ -0,0 +1,2 @@
+pub(crate) mod htlc;
+pub(crate) mod htlc_proto;

mm2src/coins/tendermint/mod.rs

@@ -2,11 +2,19 @@
 // Useful resources
 // https://docs.cosmos.network/
 
-#[path = "iris/htlc.rs"] mod htlc;
-#[path = "iris/htlc_proto.rs"] mod htlc_proto;
+mod iris;
+mod rpc;
 mod tendermint_coin;
-#[cfg(not(target_arch = "wasm32"))] mod tendermint_native_rpc;
 mod tendermint_token;
-#[cfg(target_arch = "wasm32")] mod tendermint_wasm_rpc;
+pub mod tendermint_tx_history_v2;
+
 pub use tendermint_coin::*;
 pub use tendermint_token::*;
+
+pub(crate) const TENDERMINT_COIN_PROTOCOL_TYPE: &str = "TENDERMINT";
+pub(crate) const TENDERMINT_ASSET_PROTOCOL_TYPE: &str = "TENDERMINTTOKEN";
+
+pub(crate) mod type_urls {
+    pub(crate) const CREATE_HTLC_TYPE_URL: &str = "/irismod.htlc.MsgCreateHTLC";
+    pub(crate) const CLAIM_HTLC_TYPE_URL: &str = "/irismod.htlc.MsgClaimHTLC";
+}

mm2src/coins/tendermint/rpc/mod.rs

@@ -0,0 +1,23 @@
+#[cfg(not(target_arch = "wasm32"))] mod tendermint_native_rpc;
+#[cfg(not(target_arch = "wasm32"))]
+pub use tendermint_native_rpc::*;
+
+#[cfg(target_arch = "wasm32")] mod tendermint_wasm_rpc;
+#[cfg(target_arch = "wasm32")] pub use tendermint_wasm_rpc::*;
+
+pub(crate) const TX_SUCCESS_CODE: u32 = 0;
+
+#[repr(u8)]
+pub enum TendermintResultOrder {
+    Ascending = 0,
+    Descending,
+}
+
+impl From<TendermintResultOrder> for Order {
+    fn from(order: TendermintResultOrder) -> Self {
+        match order {
+            TendermintResultOrder::Ascending => Self::Ascending,
+            TendermintResultOrder::Descending => Self::Descending,
+        }
+    }
+}

mm2src/coins/tendermint/tendermint_native_rpc.rs → mm2src/coins/tendermint/rpc/tendermint_native_rpc.rs

@@ -15,8 +15,7 @@ use tendermint_rpc::endpoint::*;
 pub use tendermint_rpc::endpoint::{abci_query::Request as AbciRequest, health::Request as HealthRequest,
                                    tx_search::Request as TxSearchRequest};
 use tendermint_rpc::Paging;
-pub use tendermint_rpc::{query::Query as TendermintQuery, Error, Order as TendermintResultOrder, Scheme,
-                         SimpleRequest, Url};
+pub use tendermint_rpc::{query::Query as TendermintQuery, Error, Order, Scheme, SimpleRequest, Url};
 use tokio::time;
 
 /// Provides lightweight access to the Tendermint RPC. It gives access to all
@@ -80,7 +79,7 @@ pub trait Client {
         query: TendermintQuery,
         page: u32,
         per_page: u8,
-        order: TendermintResultOrder,
+        order: Order,
     ) -> Result<block_search::Response, Error> {
         self.perform(block_search::Request::new(query, page, per_page, order))
             .await
@@ -229,7 +228,7 @@ pub trait Client {
         prove: bool,
         page: u32,
         per_page: u8,
-        order: TendermintResultOrder,
+        order: Order,
     ) -> Result<tx_search::Response, Error> {
         self.perform(tx_search::Request::new(query, prove, page, per_page, order))
             .await

mm2src/coins/tendermint/tendermint_wasm_rpc.rs → mm2src/coins/tendermint/rpc/tendermint_wasm_rpc.rs

@@ -16,16 +16,16 @@ pub use tendermint_rpc::endpoint::{abci_query::{AbciQuery, Request as AbciReques
 use tendermint_rpc::error::Error as TendermintRpcError;
 pub use tendermint_rpc::query::Query as TendermintQuery;
 use tendermint_rpc::request::SimpleRequest;
-pub use tendermint_rpc::Order as TendermintResultOrder;
+pub use tendermint_rpc::Order;
 use tendermint_rpc::Response;
 
 #[derive(Debug, Clone)]
-pub(super) struct HttpClient {
+pub struct HttpClient {
     uri: String,
 }
 
 #[derive(Debug, Display)]
-pub(super) enum HttpClientInitError {
+pub(crate) enum HttpClientInitError {
     InvalidUri(InvalidUri),
 }
 
@@ -34,7 +34,7 @@ impl From<InvalidUri> for HttpClientInitError {
 }
 
 #[derive(Debug, Display)]
-pub(super) enum PerformError {
+pub enum PerformError {
     TendermintRpc(TendermintRpcError),
     Slurp(SlurpError),
     #[display(fmt = "Request failed with status code {}, response {}", status_code, response)]
@@ -53,12 +53,12 @@ impl From<TendermintRpcError> for PerformError {
 }
 
 impl HttpClient {
-    pub(super) fn new(url: &str) -> Result<Self, HttpClientInitError> {
+    pub(crate) fn new(url: &str) -> Result<Self, HttpClientInitError> {
         Uri::from_str(url)?;
         Ok(HttpClient { uri: url.to_owned() })
     }
 
-    pub(super) async fn perform<R>(&self, request: R) -> Result<R::Response, PerformError>
+    pub(crate) async fn perform<R>(&self, request: R) -> Result<R::Response, PerformError>
     where
         R: SimpleRequest,
     {