merge with dev

Author: borngraced

.github/workflows/fmt-and-lint.yml

@@ -18,7 +18,7 @@ jobs:
 
       - name: Install toolchain
         run: |
-          rustup toolchain install nightly-2023-06-01 --no-self-update --profile=minimal --component rustfmt clippy
+          rustup toolchain install nightly-2023-06-01 --no-self-update --profile=minimal --component rustfmt,clippy
           rustup default nightly-2023-06-01
 
       - name: Install build deps

mm2src/coins/coin_balance.rs

@@ -1,4 +1,4 @@
-use crate::hd_wallet::{HDAccountOps, HDAddressId, HDAddressOps, HDCoinAddress, HDCoinHDAccount,
+use crate::hd_wallet::{DisplayAddress, HDAccountOps, HDAddressId, HDAddressOps, HDCoinAddress, HDCoinHDAccount,
                        HDPathAccountToAddressId, HDWalletCoinOps, HDWalletOps, HDXPubExtractor,
                        NewAccountCreationError, NewAddressDerivingError};
 use crate::{BalanceError, BalanceResult, CoinBalance, CoinBalanceMap, CoinWithDerivationMethod, DerivationMethod,
@@ -238,7 +238,7 @@ where
                 .await
                 .map(|balance| {
                     CoinBalanceReport::Iguana(IguanaWalletBalance {
-                        address: self.address_formatter()(my_address),
+                        address: my_address.display_address(),
                         balance,
                     })
                 })
@@ -351,7 +351,7 @@ pub trait HDWalletBalanceOps: HDWalletCoinOps {
             // So we can zip the derivation paths with the pairs `(Address, CoinBalance)`.
             .zip(der_paths)
             .map(|((address, balance), derivation_path)| HDAddressBalance {
-                address: self.address_formatter()(&address),
+                address: address.display_address(),
                 derivation_path: RpcDerivationPath(derivation_path),
                 chain,
                 balance,
@@ -411,8 +411,8 @@ pub enum AddressBalanceStatus<Balance> {
 
 pub mod common_impl {
     use super::*;
-    use crate::hd_wallet::{create_new_account, ExtractExtendedPubkey, HDAccountOps, HDAccountStorageOps, HDAddressOps,
-                           HDCoinExtendedPubkey, HDWalletOps};
+    use crate::hd_wallet::{create_new_account, DisplayAddress, ExtractExtendedPubkey, HDAccountOps,
+                           HDAccountStorageOps, HDAddressOps, HDCoinExtendedPubkey, HDWalletOps};
 
     pub(crate) async fn enable_hd_account<Coin>(
         coin: &Coin,
@@ -579,7 +579,7 @@ pub mod common_impl {
             let hd_address = coin.generate_new_address(hd_wallet, hd_account, chain).await?;
 
             new_addresses.push(HDAddressBalance {
-                address: coin.address_formatter()(&hd_address.address()),
+                address: hd_address.address().display_address(),
                 derivation_path: RpcDerivationPath(hd_address.derivation_path().clone()),
                 chain,
                 balance: HDWalletBalanceObject::<Coin>::new(),

mm2src/coins/eth.rs

@@ -28,8 +28,8 @@ use crate::coin_balance::{EnableCoinBalanceError, EnabledCoinBalanceParams, HDAc
                           HDWalletBalance, HDWalletBalanceOps};
 use crate::eth::eth_rpc::ETH_RPC_REQUEST_TIMEOUT;
 use crate::eth::web3_transport::websocket_transport::{WebsocketTransport, WebsocketTransportNode};
-use crate::hd_wallet::{HDAccountOps, HDCoinAddress, HDCoinWithdrawOps, HDConfirmAddress, HDPathAccountToAddressId,
-                       HDWalletCoinOps, HDXPubExtractor};
+use crate::hd_wallet::{DisplayAddress, HDAccountOps, HDCoinAddress, HDCoinWithdrawOps, HDConfirmAddress,
+                       HDPathAccountToAddressId, HDWalletCoinOps, HDXPubExtractor};
 use crate::lp_price::get_base_price_in_rel;
 use crate::nft::nft_errors::ParseContractTypeError;
 use crate::nft::nft_structs::{ContractType, ConvertChain, NftInfo, TransactionNftDetails, WithdrawErc1155,
@@ -1204,8 +1204,8 @@ pub async fn withdraw_erc721(ctx: MmArc, withdraw_type: WithdrawErc721) -> Withd
     let my_address = eth_coin.derivation_method.single_addr_or_err().await?;
     if token_owner != my_address {
         return MmError::err(WithdrawError::MyAddressNotNftOwner {
-            my_address: eth_addr_to_hex(&my_address),
-            token_owner: eth_addr_to_hex(&token_owner),
+            my_address: my_address.display_address(),
+            token_owner: token_owner.display_address(),
         });
     }
 
@@ -2296,7 +2296,7 @@ impl MarketCoinOps for EthCoin {
 
     fn my_address(&self) -> MmResult<String, MyAddressError> {
         match self.derivation_method() {
-            DerivationMethod::SingleAddress(my_address) => Ok(display_eth_address(my_address)),
+            DerivationMethod::SingleAddress(my_address) => Ok(my_address.display_address()),
             DerivationMethod::HDWallet(_) => MmError::err(MyAddressError::UnexpectedDerivationMethod(
                 "'my_address' is deprecated for HD wallets".to_string(),
             )),
@@ -3331,8 +3331,8 @@ impl EthCoin {
                     spent_by_me,
                     received_by_me,
                     total_amount,
-                    to: vec![display_eth_address(&call_data.to)],
-                    from: vec![display_eth_address(&call_data.from)],
+                    to: vec![call_data.to.display_address()],
+                    from: vec![call_data.from.display_address()],
                     coin: self.ticker.clone(),
                     fee_details: fee_details.map(|d| d.into()),
                     block_height: trace.block_number,
@@ -3711,8 +3711,8 @@ impl EthCoin {
                     spent_by_me,
                     received_by_me,
                     total_amount,
-                    to: vec![display_eth_address(&to_addr)],
-                    from: vec![display_eth_address(&from_addr)],
+                    to: vec![to_addr.display_address()],
+                    from: vec![from_addr.display_address()],
                     coin: self.ticker.clone(),
                     fee_details: fee_details.map(|d| d.into()),
                     block_height: block_number.as_u64(),
@@ -6625,16 +6625,12 @@ pub fn checksum_address(addr: &str) -> String {
 
 /// `eth_addr_to_hex` converts Address to hex format.
 /// Note: the result will be in lowercase.
-pub fn eth_addr_to_hex(address: &Address) -> String { format!("{:#02x}", address) }
+fn eth_addr_to_hex(address: &Address) -> String { format!("{:#x}", address) }
 
 /// Checks that input is valid mixed-case checksum form address
 /// The input must be 0x prefixed hex string
 fn is_valid_checksum_addr(addr: &str) -> bool { addr == checksum_address(addr) }
 
-/// `display_eth_address` converts Address to mixed-case checksum form.
-#[inline]
-pub fn display_eth_address(addr: &Address) -> String { checksum_address(&eth_addr_to_hex(addr)) }
-
 fn increase_by_percent_one_gwei(num: U256, percent: u64) -> U256 {
     let one_gwei = U256::from(10u64.pow(9));
     let percent = (num / U256::from(100)) * U256::from(percent);
@@ -6720,7 +6716,7 @@ pub async fn get_eth_address(
 
     Ok(MyWalletAddress {
         coin: ticker.to_owned(),
-        wallet_address: display_eth_address(&my_address),
+        wallet_address: my_address.display_address(),
     })
 }
 
@@ -7304,31 +7300,34 @@ impl TakerCoinSwapOpsV2 for EthCoin {
         self.refund_taker_payment_with_timelock_impl(args).await
     }
 
-    /// Eth doesnt have preimages
+    fn skip_taker_payment_spend_preimage(&self) -> bool { true }
+
+    /// Eth skips taker_payment_spend_preimage, as it doesnt need it
     async fn gen_taker_payment_spend_preimage(
         &self,
-        args: &GenTakerPaymentSpendArgs<'_, Self>,
+        _args: &GenTakerPaymentSpendArgs<'_, Self>,
         _swap_unique_data: &[u8],
     ) -> GenPreimageResult<Self> {
-        Ok(TxPreimageWithSig {
-            preimage: args.taker_tx.clone(),
-            signature: args.taker_tx.signature(),
-        })
+        MmError::err(TxGenError::Other(
+            "EVM-based coin doesn't have taker_payment_spend_preimage. Report the Bug!".to_string(),
+        ))
     }
 
-    /// Eth doesnt have preimages
+    /// Eth skips taker_payment_spend_preimage, as it doesnt need it
     async fn validate_taker_payment_spend_preimage(
         &self,
         _gen_args: &GenTakerPaymentSpendArgs<'_, Self>,
         _preimage: &TxPreimageWithSig<Self>,
     ) -> ValidateTakerPaymentSpendPreimageResult {
-        Ok(())
+        MmError::err(ValidateTakerPaymentSpendPreimageError::InvalidPreimage(
+            "EVM-based coin skips taker_payment_spend_preimage validation. Report the Bug!".to_string(),
+        ))
     }
 
-    /// Wrapper for [EthCoin::sign_and_broadcast_taker_payment_spend_impl]
+    /// Eth doesnt have preimages
     async fn sign_and_broadcast_taker_payment_spend(
         &self,
-        _preimage: &TxPreimageWithSig<Self>,
+        _preimage: Option<&TxPreimageWithSig<Self>>,
         gen_args: &GenTakerPaymentSpendArgs<'_, Self>,
         secret: &[u8],
         _swap_unique_data: &[u8],

mm2src/coins/eth/eth_hd_wallet.rs

@@ -11,6 +11,12 @@ pub type EthHDAddress = HDAddress<Address, Public>;
 pub type EthHDAccount = HDAccount<EthHDAddress, Secp256k1ExtendedPublicKey>;
 pub type EthHDWallet = HDWallet<EthHDAccount>;
 
+impl DisplayAddress for Address {
+    /// converts `Address` to mixed-case checksum form.
+    #[inline]
+    fn display_address(&self) -> String { checksum_address(&self.addr_to_string()) }
+}
+
 #[async_trait]
 impl ExtractExtendedPubkey for EthCoin {
     type ExtendedPublicKey = Secp256k1ExtendedPublicKey;
@@ -31,8 +37,6 @@ impl ExtractExtendedPubkey for EthCoin {
 impl HDWalletCoinOps for EthCoin {
     type HDWallet = EthHDWallet;
 
-    fn address_formatter(&self) -> fn(&Address) -> String { display_eth_address }
-
     fn address_from_extended_pubkey(
         &self,
         extended_pubkey: &Secp256k1ExtendedPublicKey,

mm2src/coins/eth/v2_activation.rs

@@ -413,7 +413,7 @@ impl EthCoin {
                     return MmError::err(EthTokenActivationError::CustomTokenError(
                         CustomTokenError::TokenWithSameContractAlreadyActivated {
                             ticker: token.ticker().to_string(),
-                            contract_address: display_eth_address(&protocol.token_addr),
+                            contract_address: protocol.token_addr.display_address(),
                         },
                     ));
                 },

mm2src/coins/hd_wallet/address_ops.rs

@@ -1,15 +1,29 @@
 use bip32::DerivationPath;
-use std::fmt::Display;
 use std::hash::Hash;
 
+/// A trait for converting an address into a string suitable for display in logs, errors, or messages.
+pub trait DisplayAddress {
+    fn display_address(&self) -> String;
+}
+
+/// Should convert coin `Self::Address` type into a properly formatted string representation.
+///
+/// Don't use `to_string` directly on `Self::Address` types in generic TPU code!
+/// It may produce abbreviated or non-standard formats (e.g. `ethereum_types::Address` will be like this `0x7cc9…3874`),
+/// which are not guaranteed to be parsable back into the original `Address` type.
+/// This function should ensure the resulting string is consistently formatted and fully reversible.
+pub trait AddrToString {
+    fn addr_to_string(&self) -> String;
+}
+
 /// `HDAddressOps` Trait
 ///
 /// Defines operations associated with an HD (Hierarchical Deterministic) address.
 /// In the context of BIP-44 derivation paths, an HD address corresponds to the fifth level (`address_index`)
 /// in the structure `m / purpose' / coin_type' / account' / chain (or change) / address_index`.
 /// This allows for managing individual addresses within a specific account and chain.
 pub trait HDAddressOps {
-    type Address: Clone + Display + Eq + Hash + Send + Sync;
+    type Address: Clone + DisplayAddress + Eq + Hash + Send + Sync;
     type Pubkey: Clone;
 
     fn address(&self) -> Self::Address;

mm2src/coins/hd_wallet/coin_ops.rs

@@ -1,5 +1,5 @@
-use super::{inner_impl, AccountUpdatingError, AddressDerivingError, ExtendedPublicKeyOps, HDAccountOps, HDCoinAddress,
-            HDCoinExtendedPubkey, HDCoinHDAccount, HDCoinHDAddress, HDConfirmAddress, HDWalletOps,
+use super::{inner_impl, AccountUpdatingError, AddressDerivingError, DisplayAddress, ExtendedPublicKeyOps,
+            HDAccountOps, HDCoinExtendedPubkey, HDCoinHDAccount, HDCoinHDAddress, HDConfirmAddress, HDWalletOps,
             NewAddressDeriveConfirmError, NewAddressDerivingError};
 use crate::hd_wallet::{HDAddressOps, HDWalletStorageOps, TrezorCoinError};
 use async_trait::async_trait;
@@ -25,13 +25,6 @@ pub trait HDWalletCoinOps {
     /// Any type that represents a Hierarchical Deterministic (HD) wallet.
     type HDWallet: HDWalletOps + HDWalletStorageOps + Send + Sync;
 
-    /// Returns a formatter function for address representation.
-    /// Useful when an address has multiple display formats.
-    /// For example, Ethereum addresses can be fully displayed or truncated.
-    /// By default, the formatter uses the Display trait of the address type, which truncates Ethereum addresses.
-    /// Implement this function if a different display format is required.
-    fn address_formatter(&self) -> fn(&HDCoinAddress<Self>) -> String { |address| address.to_string() }
-
     /// Derives an address for the coin that implements this trait from an extended public key and a derivation path.
     fn address_from_extended_pubkey(
         &self,
@@ -189,7 +182,7 @@ pub trait HDWalletCoinOps {
 
         let trezor_coin = self.trezor_coin()?;
         let derivation_path = hd_address.derivation_path().clone();
-        let expected_address = hd_address.address().to_string();
+        let expected_address = hd_address.address().display_address();
         // Ask the user to confirm if the given `expected_address` is the same as on the HW display.
         confirm_address
             .confirm_address(trezor_coin, derivation_path, expected_address)

mm2src/coins/hd_wallet/mod.rs

@@ -16,7 +16,7 @@ mod account_ops;
 pub use account_ops::HDAccountOps;
 
 mod address_ops;
-pub use address_ops::HDAddressOps;
+pub use address_ops::{AddrToString, DisplayAddress, HDAddressOps};
 
 mod coin_ops;
 pub use coin_ops::{HDAddressId, HDWalletCoinOps};
@@ -78,7 +78,7 @@ pub struct HDAddress<Address, Pubkey> {
 
 impl<Address, Pubkey> HDAddressOps for HDAddress<Address, Pubkey>
 where
-    Address: Clone + Display + Eq + Hash + Send + Sync,
+    Address: Clone + DisplayAddress + Eq + Hash + Send + Sync,
     Pubkey: Clone,
 {
     type Address = Address;

mm2src/coins/hd_wallet/withdraw_ops.rs

@@ -1,4 +1,4 @@
-use super::{HDPathAccountToAddressId, HDWalletOps, HDWithdrawError};
+use super::{DisplayAddress, HDPathAccountToAddressId, HDWalletOps, HDWithdrawError};
 use crate::hd_wallet::{HDAccountOps, HDAddressOps, HDCoinAddress, HDWalletCoinOps};
 use async_trait::async_trait;
 use bip32::DerivationPath;
@@ -82,7 +82,7 @@ pub trait HDCoinWithdrawOps: HDWalletCoinOps {
         let hd_address = self.derive_address(&hd_account, chain, address_id).await?;
         let address = hd_address.address();
         if !is_address_activated {
-            let error = format!("'{}' address is not activated", address);
+            let error = format!("'{}' address is not activated", address.display_address());
             return MmError::err(HDWithdrawError::UnexpectedFromAddress(error));
         }
 

mm2src/coins/lp_coins.rs

@@ -273,6 +273,7 @@ use script::Script;
 
 pub mod z_coin;
 use crate::coin_balance::{BalanceObjectOps, HDWalletBalanceObject};
+use crate::hd_wallet::{AddrToString, DisplayAddress};
 use z_coin::{ZCoin, ZcoinProtocolInfo};
 
 pub type TransactionFut = Box<dyn Future<Item = TransactionEnum, Error = TransactionErr> + Send>;
@@ -1599,16 +1600,6 @@ pub trait ToBytes {
     fn to_bytes(&self) -> Vec<u8>;
 }
 
-/// Should convert coin `Self::Address` type into a properly formatted string representation.
-///
-/// Don't use `to_string` directly on `Self::Address` types in generic TPU code!
-/// It may produce abbreviated or non-standard formats (e.g. `ethereum_types::Address` will be like this `0x7cc9…3874`),
-/// which are not guaranteed to be parsable back into the original `Address` type.
-/// This function should ensure the resulting string is consistently formatted and fully reversible.
-pub trait AddrToString {
-    fn addr_to_string(&self) -> String;
-}
-
 /// Defines associated types specific to each coin (Pubkey, Address, etc.)
 #[async_trait]
 pub trait ParseCoinAssocTypes {
@@ -2010,6 +2001,11 @@ pub trait TakerCoinSwapOpsV2: ParseCoinAssocTypes + CommonSwapOpsV2 + Send + Syn
     async fn refund_combined_taker_payment(&self, args: RefundTakerPaymentArgs<'_>)
         -> Result<Self::Tx, TransactionErr>;
 
+    /// A bool flag that allows skipping the generation and P2P message broadcasting of `TakerPaymentSpendPreimage` on the Taker side,
+    /// as well as its reception and validation on the Maker side.
+    /// This is typically used for coins that rely on smart contracts.
+    fn skip_taker_payment_spend_preimage(&self) -> bool { false }
+
     /// Generates and signs taker payment spend preimage. The preimage and signature should be
     /// shared with maker to proceed with protocol execution.
     async fn gen_taker_payment_spend_preimage(
@@ -2028,7 +2024,7 @@ pub trait TakerCoinSwapOpsV2: ParseCoinAssocTypes + CommonSwapOpsV2 + Send + Syn
     /// Sign and broadcast taker payment spend on maker's side.
     async fn sign_and_broadcast_taker_payment_spend(
         &self,
-        preimage: &TxPreimageWithSig<Self>,
+        preimage: Option<&TxPreimageWithSig<Self>>,
         gen_args: &GenTakerPaymentSpendArgs<'_, Self>,
         secret: &[u8],
         swap_unique_data: &[u8],
@@ -5003,7 +4999,7 @@ pub async fn delegations_info(ctx: MmArc, req: DelegationsInfo) -> Result<Json,
         DelegationsInfoDetails::Qtum => {
             let MmCoinEnum::QtumCoin(qtum) = coin else {
                 return MmError::err(StakingInfoError::InvalidPayload {
-                    reason: format!("{} is not a Qtum coin", req.coin)
+                    reason: format!("{} is not a Qtum coin", req.coin),
                 });
             };
 
@@ -5054,7 +5050,7 @@ pub async fn claim_staking_rewards(ctx: MmArc, req: ClaimStakingRewardsRequest)
 
             let MmCoinEnum::Tendermint(tendermint) = coin else {
                 return MmError::err(DelegationError::InvalidPayload {
-                    reason: format!("{} is not a Cosmos coin", req.coin)
+                    reason: format!("{} is not a Cosmos coin", req.coin),
                 });
             };
 
@@ -5749,7 +5745,7 @@ where
                         .await?
                         .into_iter()
                         .map(|empty_address| HDAddressBalance {
-                            address: coin.address_formatter()(&empty_address.address()),
+                            address: empty_address.address().display_address(),
                             derivation_path: RpcDerivationPath(empty_address.derivation_path().clone()),
                             chain,
                             balance: HDWalletBalanceObject::<T>::new(),
@@ -5758,7 +5754,7 @@ where
 
                 // Then push this non-empty address.
                 balances.push(HDAddressBalance {
-                    address: coin.address_formatter()(&checking_address),
+                    address: checking_address.display_address(),
                     derivation_path: RpcDerivationPath(checking_address_der_path.clone()),
                     chain,
                     balance: non_empty_balance,