[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

@@ -217,8 +217,8 @@ use rpc_command::{init_account_balance::{AccountBalanceTaskManager, AccountBalan
                   init_withdraw::{WithdrawTaskManager, WithdrawTaskManagerShared}};
 
 pub mod tendermint;
-use tendermint::{CosmosTransaction, TendermintCoin, TendermintFeeDetails, TendermintProtocolInfo, TendermintToken,
-                 TendermintTokenProtocolInfo};
+use tendermint::{CosmosTransaction, CustomTendermintMsgType, TendermintCoin, TendermintFeeDetails,
+                 TendermintProtocolInfo, TendermintToken, TendermintTokenProtocolInfo};
 
 #[doc(hidden)]
 #[allow(unused_variables)]
@@ -1036,16 +1036,18 @@ impl KmdRewardsDetails {
     }
 }
 
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[derive(Default, Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub enum TransactionType {
     StakingDelegation,
     RemoveDelegation,
+    #[default]
     StandardTransfer,
     TokenTransfer(BytesJson),
-}
-
-impl Default for TransactionType {
-    fn default() -> Self { TransactionType::StandardTransfer }
+    FeeForTokenTx,
+    CustomTendermintMsg {
+        msg_type: CustomTendermintMsgType,
+        token_id: Option<BytesJson>,
+    },
 }
 
 /// Transaction details
@@ -1908,7 +1910,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,6 +15,7 @@ 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;
 
@@ -69,6 +72,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,
@@ -215,8 +221,18 @@ impl<'a, Addr: Clone + DisplayAddress + Eq + std::hash::Hash, Tx: Transaction> T
                 bytes_for_hash.extend_from_slice(&token_id.0);
                 sha256(&bytes_for_hash).to_vec().into()
             },
+            TransactionType::CustomTendermintMsg { token_id, .. } => {
+                if let Some(token_id) = 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()
+                } else {
+                    tx_hash.clone()
+                }
+            },
             TransactionType::StakingDelegation
             | TransactionType::RemoveDelegation
+            | TransactionType::FeeForTokenTx
             | TransactionType::StandardTransfer => tx_hash.clone(),
         };
 
@@ -375,6 +391,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,6 +424,10 @@ where
         .get_history(&wallet_id, filters, request.paging_options.clone(), request.limit)
         .await?;
 
+    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()
@@ -414,6 +436,59 @@ where
             if details.coin != request.coin {
                 details.coin = request.coin.clone();
             }
+
+            // TODO
+            // !! temporary solution !!
+            // for tendermint, tx_history_v2 implementation doesn't include amount parsing logic.
+            // therefore, re-mapping is required
+            match protocol_type {
+                TENDERMINT_COIN_PROTOCOL_TYPE | TENDERMINT_ASSET_PROTOCOL_TYPE => {
+                    // TODO
+                    // see this https://github.com/KomodoPlatform/atomicDEX-API/pull/1526#discussion_r1037001780
+                    if let Some(TxFeeDetails::Utxo(fee)) = &mut details.fee_details {
+                        let mapped_fee = crate::tendermint::TendermintFeeDetails {
+                            // We make sure this is filled in `tendermint_tx_history_v2`
+                            coin: fee.coin.as_ref().expect("can't be empty").to_owned(),
+                            amount: fee.amount.clone(),
+                            gas_limit: crate::tendermint::GAS_LIMIT_DEFAULT,
+                            // ignored anyway
+                            uamount: 0,
+                        };
+                        details.fee_details = Some(TxFeeDetails::Tendermint(mapped_fee));
+                    }
+
+                    match &details.transaction_type {
+                        // Amount mappings are by-passed when `TransactionType` is `FeeForTokenTx`
+                        TransactionType::FeeForTokenTx => {},
+                        _ => {
+                            // 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 {

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,29 @@
 // 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::*;
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub enum CustomTendermintMsgType {
+    /// Create HTLC as sender
+    SendHtlcAmount,
+    /// Claim HTLC as reciever
+    ClaimHtlcAmount,
+    /// Claim HTLC for reciever
+    SignClaimHtlc,
+}
+
+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 = 1,
+    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