feat(nft): enable eth with non fungible tokens

mm2src/coins/coin_errors.rs

@@ -35,6 +35,8 @@ pub enum ValidatePaymentError {
     WatcherRewardError(String),
     /// Input payment timelock overflows the type used by specific coin.
     TimelockOverflow(TryFromIntError),
+    #[display(fmt = "Nft Protocol is not supported yet!")]
+    NftProtocolNotSupported,
 }
 
 impl From<rlp::DecoderError> for ValidatePaymentError {
@@ -79,6 +81,7 @@ impl From<Web3RpcError> for ValidatePaymentError {
             Web3RpcError::Internal(internal) | Web3RpcError::Timeout(internal) => {
                 ValidatePaymentError::InternalError(internal)
             },
+            Web3RpcError::NftProtocolNotSupported => ValidatePaymentError::NftProtocolNotSupported,
         }
     }
 }

mm2src/coins/eth/eth_tests.rs

@@ -131,6 +131,7 @@ fn eth_coin_from_keypair(
     let ticker = match coin_type {
         EthCoinType::Eth => "ETH".to_string(),
         EthCoinType::Erc20 { .. } => "JST".to_string(),
+        EthCoinType::Nft { ref platform } => platform.to_string(),
     };
 
     let eth_coin = EthCoin(Arc::new(EthCoinImpl {
@@ -154,6 +155,7 @@ fn eth_coin_from_keypair(
         logs_block_range: DEFAULT_LOGS_BLOCK_RANGE,
         nonce_lock: new_nonce_lock(),
         erc20_tokens_infos: Default::default(),
+        nfts_infos: Default::default(),
         abortable_system: AbortableQueue::default(),
     }));
     (ctx, eth_coin)
@@ -364,6 +366,7 @@ fn test_nonce_several_urls() {
         logs_block_range: DEFAULT_LOGS_BLOCK_RANGE,
         nonce_lock: new_nonce_lock(),
         erc20_tokens_infos: Default::default(),
+        nfts_infos: Default::default(),
         abortable_system: AbortableQueue::default(),
     }));
 
@@ -415,6 +418,7 @@ fn test_wait_for_payment_spend_timeout() {
         logs_block_range: DEFAULT_LOGS_BLOCK_RANGE,
         nonce_lock: new_nonce_lock(),
         erc20_tokens_infos: Default::default(),
+        nfts_infos: Default::default(),
         abortable_system: AbortableQueue::default(),
     };
 
@@ -1126,6 +1130,7 @@ fn test_message_hash() {
         logs_block_range: DEFAULT_LOGS_BLOCK_RANGE,
         nonce_lock: new_nonce_lock(),
         erc20_tokens_infos: Default::default(),
+        nfts_infos: Default::default(),
         abortable_system: AbortableQueue::default(),
     }));
 
@@ -1173,6 +1178,7 @@ fn test_sign_verify_message() {
         logs_block_range: DEFAULT_LOGS_BLOCK_RANGE,
         nonce_lock: new_nonce_lock(),
         erc20_tokens_infos: Default::default(),
+        nfts_infos: Default::default(),
         abortable_system: AbortableQueue::default(),
     }));
 
@@ -1229,6 +1235,7 @@ fn test_eth_extract_secret() {
         logs_block_range: DEFAULT_LOGS_BLOCK_RANGE,
         nonce_lock: new_nonce_lock(),
         erc20_tokens_infos: Default::default(),
+        nfts_infos: Default::default(),
         abortable_system: AbortableQueue::default(),
     }));
 

mm2src/coins/eth/eth_wasm_tests.rs

@@ -49,6 +49,7 @@ async fn test_send() {
         logs_block_range: DEFAULT_LOGS_BLOCK_RANGE,
         nonce_lock: new_nonce_lock(),
         erc20_tokens_infos: Default::default(),
+        nfts_infos: Default::default(),
         abortable_system: AbortableQueue::default(),
     }));
     let maker_payment_args = SendPaymentArgs {

mm2src/coins/eth/v2_activation.rs

@@ -1,4 +1,7 @@
 use super::*;
+use crate::nft::get_nfts_for_activation;
+use crate::nft::nft_errors::{GetNftInfoError, ParseChainTypeError};
+use crate::nft::nft_structs::Chain;
 #[cfg(target_arch = "wasm32")] use crate::EthMetamaskPolicy;
 use common::executor::AbortedError;
 use crypto::{CryptoCtxError, StandardHDCoinAddress};
@@ -7,6 +10,8 @@ use instant::Instant;
 use mm2_err_handle::common_errors::WithInternal;
 #[cfg(target_arch = "wasm32")]
 use mm2_metamask::{from_metamask_error, MetamaskError, MetamaskRpcError, WithMetamaskRpcError};
+use std::sync::atomic::Ordering;
+use url::Url;
 use web3_transport::websocket_transport::WebsocketTransport;
 
 #[derive(Clone, Debug, Deserialize, Display, EnumFromTrait, PartialEq, Serialize, SerializeErrorType)]
@@ -39,6 +44,7 @@ pub enum EthActivationV2Error {
     #[from_trait(WithInternal::internal)]
     #[display(fmt = "Internal: {}", _0)]
     InternalError(String),
+    Transport(String),
 }
 
 impl From<MyAddressError> for EthActivationV2Error {
@@ -57,11 +63,28 @@ impl From<UnexpectedDerivationMethod> for EthActivationV2Error {
     fn from(e: UnexpectedDerivationMethod) -> Self { EthActivationV2Error::InternalError(e.to_string()) }
 }
 
+impl From<EthTokenActivationError> for EthActivationV2Error {
+    fn from(e: EthTokenActivationError) -> Self {
+        match e {
+            EthTokenActivationError::InternalError(err) => EthActivationV2Error::InternalError(err),
+            EthTokenActivationError::CouldNotFetchBalance(err) => EthActivationV2Error::CouldNotFetchBalance(err),
+            EthTokenActivationError::InvalidPayload(err) => EthActivationV2Error::InvalidPayload(err),
+            EthTokenActivationError::Transport(err) | EthTokenActivationError::ClientConnectionFailed(err) => {
+                EthActivationV2Error::Transport(err)
+            },
+        }
+    }
+}
+
 #[cfg(target_arch = "wasm32")]
 impl From<MetamaskError> for EthActivationV2Error {
     fn from(e: MetamaskError) -> Self { from_metamask_error(e) }
 }
 
+impl From<ParseChainTypeError> for EthActivationV2Error {
+    fn from(e: ParseChainTypeError) -> Self { EthActivationV2Error::InternalError(e.to_string()) }
+}
+
 /// An alternative to `crate::PrivKeyActivationPolicy`, typical only for ETH coin.
 #[derive(Clone, Deserialize)]
 pub enum EthPrivKeyActivationPolicy {
@@ -116,44 +139,113 @@ pub struct EthNode {
 
 #[derive(Serialize, SerializeErrorType)]
 #[serde(tag = "error_type", content = "error_data")]
-pub enum Erc20TokenActivationError {
+pub enum EthTokenActivationError {
     InternalError(String),
     ClientConnectionFailed(String),
     CouldNotFetchBalance(String),
+    InvalidPayload(String),
+    Transport(String),
 }
 
-impl From<AbortedError> for Erc20TokenActivationError {
-    fn from(e: AbortedError) -> Self { Erc20TokenActivationError::InternalError(e.to_string()) }
+impl From<AbortedError> for EthTokenActivationError {
+    fn from(e: AbortedError) -> Self { EthTokenActivationError::InternalError(e.to_string()) }
 }
 
-impl From<MyAddressError> for Erc20TokenActivationError {
+impl From<MyAddressError> for EthTokenActivationError {
     fn from(err: MyAddressError) -> Self { Self::InternalError(err.to_string()) }
 }
 
+impl From<GetNftInfoError> for EthTokenActivationError {
+    fn from(e: GetNftInfoError) -> Self {
+        match e {
+            GetNftInfoError::InvalidRequest(err) => EthTokenActivationError::InvalidPayload(err),
+            GetNftInfoError::ContractTypeIsNull => EthTokenActivationError::InvalidPayload(
+                "The contract type is required and should not be null.".to_string(),
+            ),
+            GetNftInfoError::Transport(err) | GetNftInfoError::InvalidResponse(err) => {
+                EthTokenActivationError::Transport(err)
+            },
+            GetNftInfoError::Internal(err) | GetNftInfoError::DbError(err) | GetNftInfoError::NumConversError(err) => {
+                EthTokenActivationError::InternalError(err)
+            },
+            GetNftInfoError::GetEthAddressError(err) => EthTokenActivationError::InternalError(err.to_string()),
+            GetNftInfoError::ParseRfc3339Err(err) => EthTokenActivationError::InternalError(err.to_string()),
+            GetNftInfoError::ProtectFromSpamError(err) => EthTokenActivationError::InternalError(err.to_string()),
+            GetNftInfoError::TransferConfirmationsError(err) => EthTokenActivationError::InternalError(err.to_string()),
+            GetNftInfoError::TokenNotFoundInWallet {
+                token_address,
+                token_id,
+            } => EthTokenActivationError::InternalError(format!(
+                "Token not found in wallet: {}, {}",
+                token_address, token_id
+            )),
+        }
+    }
+}
+
+impl From<ParseChainTypeError> for EthTokenActivationError {
+    fn from(e: ParseChainTypeError) -> Self { EthTokenActivationError::InternalError(e.to_string()) }
+}
+
+/// Represents the parameters required for activating either an ERC-20 token or an NFT on the Ethereum platform.
+#[derive(Clone, Deserialize)]
+#[serde(untagged)]
+pub enum EthTokenActivationParams {
+    Nft(NftActivationRequest),
+    Erc20(Erc20TokenActivationRequest),
+}
+
+/// Holds ERC-20 token-specific activation parameters, including optional confirmation requirements.
 #[derive(Clone, Deserialize)]
 pub struct Erc20TokenActivationRequest {
     pub required_confirmations: Option<u64>,
 }
 
+/// Encapsulates the request parameters for NFT activation, specifying the provider to be used.
+#[derive(Clone, Deserialize)]
+pub struct NftActivationRequest {
+    pub provider: NftProviderEnum,
+}
+
+/// Defines available NFT providers and their configuration.
+#[derive(Clone, Deserialize)]
+#[serde(tag = "type", content = "info")]
+pub enum NftProviderEnum {
+    Moralis { url: Url },
+}
+
+/// Represents the protocol type for an Ethereum-based token, distinguishing between ERC-20 tokens and NFTs.
+pub enum EthTokenProtocol {
+    Erc20(Erc20Protocol),
+    Nft(NftProtocol),
+}
+
+/// Details for an ERC-20 token protocol.
 pub struct Erc20Protocol {
     pub platform: String,
     pub token_addr: Address,
 }
 
+/// Details for an NFT protocol.
+#[derive(Debug)]
+pub struct NftProtocol {
+    pub platform: String,
+}
+
 #[cfg_attr(test, mockable)]
 impl EthCoin {
     pub async fn initialize_erc20_token(
         &self,
         activation_params: Erc20TokenActivationRequest,
         protocol: Erc20Protocol,
         ticker: String,
-    ) -> MmResult<EthCoin, Erc20TokenActivationError> {
+    ) -> MmResult<EthCoin, EthTokenActivationError> {
         // TODO
         // Check if ctx is required.
         // Remove it to avoid circular references if possible
         let ctx = MmArc::from_weak(&self.ctx)
             .ok_or_else(|| String::from("No context"))
-            .map_err(Erc20TokenActivationError::InternalError)?;
+            .map_err(EthTokenActivationError::InternalError)?;
 
         let conf = coin_conf(&ctx, &ticker);
 
@@ -162,11 +254,11 @@ impl EthCoin {
                 &self
                     .web3()
                     .await
-                    .map_err(|e| Erc20TokenActivationError::ClientConnectionFailed(e.to_string()))?,
+                    .map_err(|e| EthTokenActivationError::ClientConnectionFailed(e.to_string()))?,
                 protocol.token_addr,
             )
             .await
-            .map_err(Erc20TokenActivationError::InternalError)?,
+            .map_err(EthTokenActivationError::InternalError)?,
             Some(d) => d as u8,
         };
 
@@ -221,11 +313,59 @@ impl EthCoin {
             logs_block_range: self.logs_block_range,
             nonce_lock: self.nonce_lock.clone(),
             erc20_tokens_infos: Default::default(),
+            nfts_infos: Default::default(),
             abortable_system,
         };
 
         Ok(EthCoin(Arc::new(token)))
     }
+
+    /// Initializes a Global NFT instance for a specific blockchain platform (e.g., Ethereum, Polygon).
+    ///
+    /// A "Global NFT" consolidates information about all NFTs owned by a user into a single `EthCoin` instance,
+    /// avoiding the need for separate instances for each NFT.
+    /// The function configures the necessary settings for the Global NFT, including web3 connections and confirmation requirements.
+    /// It fetches NFT details from a given URL to populate the `nfts_infos` field, which stores information about the user's NFTs.
+    ///
+    /// This setup allows the Global NFT to function like a coin, supporting swap operations and providing easy access to NFT details via `nfts_infos`.
+    pub async fn global_nft_from_platform_coin(&self, url: &Url) -> MmResult<EthCoin, EthTokenActivationError> {
+        let chain = Chain::from_ticker(self.ticker())?;
+        let ticker = chain.to_nft_ticker().to_string();
+
+        // Create an abortable system linked to the `platform_coin` (which is self) so if the platform coin is disabled,
+        // all spawned futures related to global Non-Fungible Token will be aborted as well.
+        let abortable_system = self.abortable_system.create_subsystem()?;
+
+        let nft_infos = get_nfts_for_activation(&chain, &self.my_address, url).await?;
+
+        let global_nft = EthCoinImpl {
+            ticker,
+            coin_type: EthCoinType::Nft {
+                platform: self.ticker.clone(),
+            },
+            priv_key_policy: self.priv_key_policy.clone(),
+            my_address: self.my_address,
+            sign_message_prefix: self.sign_message_prefix.clone(),
+            swap_contract_address: self.swap_contract_address,
+            fallback_swap_contract: self.fallback_swap_contract,
+            contract_supports_watchers: self.contract_supports_watchers,
+            web3_instances: self.web3_instances.lock().await.clone().into(),
+            decimals: self.decimals,
+            gas_station_url: self.gas_station_url.clone(),
+            gas_station_decimals: self.gas_station_decimals,
+            gas_station_policy: self.gas_station_policy.clone(),
+            history_sync_state: Mutex::new(self.history_sync_state.lock().unwrap().clone()),
+            required_confirmations: AtomicU64::new(self.required_confirmations.load(Ordering::Relaxed)),
+            ctx: self.ctx.clone(),
+            chain_id: self.chain_id,
+            logs_block_range: self.logs_block_range,
+            nonce_lock: self.nonce_lock.clone(),
+            erc20_tokens_infos: Default::default(),
+            nfts_infos: Arc::new(AsyncMutex::new(nft_infos)),
+            abortable_system,
+        };
+        Ok(EthCoin(Arc::new(global_nft)))
+    }
 }
 
 pub async fn eth_coin_from_conf_and_request_v2(
@@ -329,6 +469,7 @@ pub async fn eth_coin_from_conf_and_request_v2(
         logs_block_range: conf["logs_block_range"].as_u64().unwrap_or(DEFAULT_LOGS_BLOCK_RANGE),
         nonce_lock,
         erc20_tokens_infos: Default::default(),
+        nfts_infos: Default::default(),
         abortable_system,
     };