Withdraw ERC1155 and EVM based chains support added for NFT PoC

CHANGELOG.md

@@ -3,6 +3,7 @@
 **Features:**
 - NFT integration `WIP` [#900](https://github.com/KomodoPlatform/atomicDEX-API/issues/900)
   - NFT integration PoC added. Includes ERC721 support for ETH and BSC [#1652](https://github.com/KomodoPlatform/atomicDEX-API/pull/1652)
+  - Withdraw ERC1155 and EVM based chains support added for NFT PoC [#1704](https://github.com/KomodoPlatform/atomicDEX-API/pull/1704)
 - Swap watcher nodes [#1431](https://github.com/KomodoPlatform/atomicDEX-API/issues/1431)
   - Watcher rewards for ETH swaps were added [#1658](https://github.com/KomodoPlatform/atomicDEX-API/pull/1658)
 - Cosmos integration `WIP` [#1432](https://github.com/KomodoPlatform/atomicDEX-API/issues/1432)

mm2src/coins/eth/v2_activation.rs

@@ -6,7 +6,7 @@ use mm2_err_handle::common_errors::WithInternal;
 #[cfg(target_arch = "wasm32")]
 use mm2_metamask::{from_metamask_error, MetamaskError, MetamaskRpcError, WithMetamaskRpcError};
 
-#[derive(Debug, Deserialize, Display, EnumFromTrait, Serialize, SerializeErrorType)]
+#[derive(Clone, Debug, Deserialize, Display, EnumFromTrait, PartialEq, Serialize, SerializeErrorType)]
 #[serde(tag = "error_type", content = "error_data")]
 pub enum EthActivationV2Error {
     InvalidPayload(String),

mm2src/coins/lp_coins.rs

@@ -208,7 +208,10 @@ use coin_errors::{MyAddressError, ValidatePaymentError, ValidatePaymentFut};
 pub mod coins_tests;
 
 pub mod eth;
-use eth::{eth_coin_from_conf_and_request, get_eth_address, EthCoin, EthTxFeeDetails, GetEthAddressError, SignedEthTx};
+#[cfg(feature = "enable-nft-integration")]
+use eth::GetValidEthWithdrawAddError;
+use eth::{eth_coin_from_conf_and_request, get_eth_address, EthCoin, EthGasDetailsErr, EthTxFeeDetails,
+          GetEthAddressError, SignedEthTx};
 
 pub mod hd_confirm_address;
 pub mod hd_pubkey;
@@ -279,6 +282,8 @@ use utxo::UtxoActivationParams;
 use utxo::{BlockchainNetwork, GenerateTxError, UtxoFeeDetails, UtxoTx};
 
 #[cfg(feature = "enable-nft-integration")] pub mod nft;
+#[cfg(feature = "enable-nft-integration")]
+use nft::nft_errors::GetNftInfoError;
 
 #[cfg(not(target_arch = "wasm32"))] pub mod z_coin;
 #[cfg(not(target_arch = "wasm32"))] use z_coin::ZCoin;
@@ -427,7 +432,7 @@ pub enum TxHistoryError {
     InternalError(String),
 }
 
-#[derive(Clone, Debug, Display, Deserialize)]
+#[derive(Clone, Debug, Deserialize, Display, PartialEq)]
 pub enum PrivKeyPolicyNotAllowed {
     #[display(fmt = "Hardware Wallet is not supported")]
     HardwareWalletNotSupported,
@@ -1770,7 +1775,7 @@ impl DelegationError {
     }
 }
 
-#[derive(Clone, Debug, Display, EnumFromStringify, EnumFromTrait, Serialize, SerializeErrorType, PartialEq)]
+#[derive(Clone, Debug, Display, EnumFromStringify, EnumFromTrait, PartialEq, Serialize, SerializeErrorType)]
 #[serde(tag = "error_type", content = "error_data")]
 pub enum WithdrawError {
     #[display(
@@ -1833,14 +1838,38 @@ pub enum WithdrawError {
     #[from_stringify("NumConversError", "UnexpectedDerivationMethod", "PrivKeyPolicyNotAllowed")]
     #[display(fmt = "Internal error: {}", _0)]
     InternalError(String),
+    #[cfg(feature = "enable-nft-integration")]
     #[display(fmt = "{} coin doesn't support NFT withdrawing", coin)]
     CoinDoesntSupportNftWithdraw { coin: String },
+    #[cfg(feature = "enable-nft-integration")]
     #[display(fmt = "My address {} and from address {} mismatch", my_address, from)]
     AddressMismatchError { my_address: String, from: String },
+    #[cfg(feature = "enable-nft-integration")]
     #[display(fmt = "Contract type {} doesnt support 'withdraw_nft' yet", _0)]
     ContractTypeDoesntSupportNftWithdrawing(String),
     #[display(fmt = "Action not allowed for coin: {}", _0)]
     ActionNotAllowed(String),
+    #[cfg(feature = "enable-nft-integration")]
+    GetNftInfoError(GetNftInfoError),
+    #[cfg(feature = "enable-nft-integration")]
+    #[display(
+        fmt = "Not enough NFTs amount with token_address: {} and token_id {}. Available {}, required {}",
+        token_address,
+        token_id,
+        available,
+        required
+    )]
+    NotEnoughNftsAmount {
+        token_address: String,
+        token_id: String,
+        available: BigDecimal,
+        required: BigDecimal,
+    },
+}
+
+#[cfg(feature = "enable-nft-integration")]
+impl From<GetNftInfoError> for WithdrawError {
+    fn from(e: GetNftInfoError) -> Self { WithdrawError::GetNftInfoError(e) }
 }
 
 impl HttpStatusCode for WithdrawError {
@@ -1860,14 +1889,17 @@ impl HttpStatusCode for WithdrawError {
             | WithdrawError::UnexpectedFromAddress(_)
             | WithdrawError::UnknownAccount { .. }
             | WithdrawError::UnexpectedUserAction { .. }
-            | WithdrawError::CoinDoesntSupportNftWithdraw { .. }
-            | WithdrawError::AddressMismatchError { .. }
-            | WithdrawError::ActionNotAllowed(_)
-            | WithdrawError::ContractTypeDoesntSupportNftWithdrawing(_) => StatusCode::BAD_REQUEST,
+            | WithdrawError::ActionNotAllowed(_) => StatusCode::BAD_REQUEST,
             WithdrawError::HwError(_) => StatusCode::GONE,
             #[cfg(target_arch = "wasm32")]
             WithdrawError::BroadcastExpected(_) => StatusCode::BAD_REQUEST,
             WithdrawError::Transport(_) | WithdrawError::InternalError(_) => StatusCode::INTERNAL_SERVER_ERROR,
+            #[cfg(feature = "enable-nft-integration")]
+            WithdrawError::GetNftInfoError(_)
+            | WithdrawError::AddressMismatchError { .. }
+            | WithdrawError::ContractTypeDoesntSupportNftWithdrawing(_)
+            | WithdrawError::CoinDoesntSupportNftWithdraw { .. }
+            | WithdrawError::NotEnoughNftsAmount { .. } => StatusCode::BAD_REQUEST,
         }
     }
 }
@@ -1902,6 +1934,31 @@ impl From<TimeoutError> for WithdrawError {
     fn from(e: TimeoutError) -> Self { WithdrawError::Timeout(e.duration) }
 }
 
+#[cfg(feature = "enable-nft-integration")]
+impl From<GetValidEthWithdrawAddError> for WithdrawError {
+    fn from(e: GetValidEthWithdrawAddError) -> Self {
+        match e {
+            GetValidEthWithdrawAddError::AddressMismatchError { my_address, from } => {
+                WithdrawError::AddressMismatchError { my_address, from }
+            },
+            GetValidEthWithdrawAddError::CoinDoesntSupportNftWithdraw { coin } => {
+                WithdrawError::CoinDoesntSupportNftWithdraw { coin }
+            },
+            GetValidEthWithdrawAddError::InvalidAddress(e) => WithdrawError::InvalidAddress(e),
+        }
+    }
+}
+
+impl From<EthGasDetailsErr> for WithdrawError {
+    fn from(e: EthGasDetailsErr) -> Self {
+        match e {
+            EthGasDetailsErr::InvalidFeePolicy(e) => WithdrawError::InvalidFeePolicy(e),
+            EthGasDetailsErr::Internal(e) => WithdrawError::InternalError(e),
+            EthGasDetailsErr::Transport(e) => WithdrawError::Transport(e),
+        }
+    }
+}
+
 impl WithdrawError {
     /// Construct [`WithdrawError`] from [`GenerateTxError`] using additional `coin` and `decimals`.
     pub fn from_generate_tx_error(gen_tx_err: GenerateTxError, coin: String, decimals: u8) -> WithdrawError {

mm2src/coins/nft.rs

@@ -6,12 +6,14 @@ pub(crate) mod nft_structs;
 
 use crate::WithdrawError;
 use nft_errors::GetNftInfoError;
-use nft_structs::{Chain, Nft, NftList, NftListReq, NftMetadataReq, NftTransferHistory, NftTransferHistoryWrapper,
-                  NftTransfersReq, NftWrapper, NftsTransferHistoryList, TransactionNftDetails, WithdrawNftReq};
+use nft_structs::{Chain, ConvertChain, Nft, NftList, NftListReq, NftMetadataReq, NftTransferHistory,
+                  NftTransferHistoryWrapper, NftTransfersReq, NftWrapper, NftsTransferHistoryList,
+                  TransactionNftDetails, WithdrawNftReq};
 
-use crate::eth::{get_eth_address, withdraw_erc721};
+use crate::eth::{get_eth_address, withdraw_erc1155, withdraw_erc721};
 use common::{APPLICATION_JSON, X_API_KEY};
 use http::header::ACCEPT;
+use mm2_number::BigDecimal;
 use serde_json::Value as Json;
 
 /// url for moralis requests
@@ -23,7 +25,7 @@ const DIRECTION_BOTH_MORALIS: &str = "direction=both";
 
 pub type WithdrawNftResult = Result<TransactionNftDetails, MmError<WithdrawError>>;
 
-/// `get_nft_list` function returns list of NFTs on ETH or/and BNB chains owned by user.
+/// `get_nft_list` function returns list of NFTs on requested chains owned by user.
 pub async fn get_nft_list(ctx: MmArc, req: NftListReq) -> MmResult<NftList, GetNftInfoError> {
     let api_key = ctx.conf["api_key"]
         .as_str()
@@ -32,11 +34,8 @@ pub async fn get_nft_list(ctx: MmArc, req: NftListReq) -> MmResult<NftList, GetN
     let mut res_list = Vec::new();
 
     for chain in req.chains {
-        let (coin_str, chain_str) = match chain {
-            Chain::Bsc => ("BNB", "bsc"),
-            Chain::Eth => ("ETH", "eth"),
-        };
-        let my_address = get_eth_address(&ctx, coin_str).await?;
+        let (coin_str, chain_str) = chain.to_ticker_chain();
+        let my_address = get_eth_address(&ctx, &coin_str).await?;
         let uri_without_cursor = format!(
             "{}{}/nft?chain={}&{}",
             URL_MORALIS, my_address.wallet_address, chain_str, FORMAT_DECIMAL_MORALIS
@@ -83,24 +82,28 @@ pub async fn get_nft_list(ctx: MmArc, req: NftListReq) -> MmResult<NftList, GetN
         }
     }
     drop_mutability!(res_list);
-    let nft_list = NftList {
-        count: res_list.len() as u64,
-        nfts: res_list,
-    };
+    let nft_list = NftList { nfts: res_list };
     Ok(nft_list)
 }
 
 /// `get_nft_metadata` function returns info of one specific NFT.
 /// Current implementation sends request to Moralis.
 /// Later, after adding caching, metadata lookup can be performed using previously obtained NFTs info without
 /// sending new moralis request. The moralis request can be sent as a fallback, if the data was not found in the cache.
+///
+/// **Caution:** ERC-1155 token can have a total supply more than 1, which means there could be several owners
+/// of the same token. `get_nft_metadata` returns NFTs info with the most recent owner.
+/// **Dont** use this function to get specific info about owner address, amount etc, you will get info not related to my_address.
 pub async fn get_nft_metadata(ctx: MmArc, req: NftMetadataReq) -> MmResult<Nft, GetNftInfoError> {
     let api_key = ctx.conf["api_key"]
         .as_str()
         .ok_or_else(|| MmError::new(GetNftInfoError::ApiKeyError))?;
     let chain_str = match req.chain {
+        Chain::Avalanche => "avalanche",
         Chain::Bsc => "bsc",
         Chain::Eth => "eth",
+        Chain::Fantom => "fantom",
+        Chain::Polygon => "polygon",
     };
     let uri = format!(
         "{}nft/{}/{}?chain={}&{}",
@@ -129,7 +132,7 @@ pub async fn get_nft_metadata(ctx: MmArc, req: NftMetadataReq) -> MmResult<Nft,
     Ok(nft_metadata)
 }
 
-/// `get_nft_transfers` function returns a transfer history of NFTs on ETH or/and BNb chains owned by user.
+/// `get_nft_transfers` function returns a transfer history of NFTs on requested chains owned by user.
 /// Currently doesnt support filters.
 pub async fn get_nft_transfers(ctx: MmArc, req: NftTransfersReq) -> MmResult<NftsTransferHistoryList, GetNftInfoError> {
     let api_key = ctx.conf["api_key"]
@@ -140,8 +143,11 @@ pub async fn get_nft_transfers(ctx: MmArc, req: NftTransfersReq) -> MmResult<Nft
 
     for chain in req.chains {
         let (coin_str, chain_str) = match chain {
+            Chain::Avalanche => ("AVAX", "avalanche"),
             Chain::Bsc => ("BNB", "bsc"),
             Chain::Eth => ("ETH", "eth"),
+            Chain::Fantom => ("FTM", "fantom"),
+            Chain::Polygon => ("MATIC", "polygon"),
         };
         let my_address = get_eth_address(&ctx, coin_str).await?;
         let uri_without_cursor = format!(
@@ -192,7 +198,6 @@ pub async fn get_nft_transfers(ctx: MmArc, req: NftTransfersReq) -> MmResult<Nft
     }
     drop_mutability!(res_list);
     let transfer_history_list = NftsTransferHistoryList {
-        count: res_list.len() as u64,
         transfer_history: res_list,
     };
     Ok(transfer_history_list)
@@ -201,12 +206,9 @@ pub async fn get_nft_transfers(ctx: MmArc, req: NftTransfersReq) -> MmResult<Nft
 /// `withdraw_nft` function generates, signs and returns a transaction that transfers NFT
 /// from my address to recipient's address.
 /// This method generates a raw transaction which should then be broadcast using `send_raw_transaction`.
-/// Currently support ERC721 withdrawing, ERC1155 support will be added later.
 pub async fn withdraw_nft(ctx: MmArc, req_type: WithdrawNftReq) -> WithdrawNftResult {
     match req_type {
-        WithdrawNftReq::WithdrawErc1155(_) => MmError::err(WithdrawError::ContractTypeDoesntSupportNftWithdrawing(
-            "ERC1155".to_owned(),
-        )),
+        WithdrawNftReq::WithdrawErc1155(erc1155_req) => withdraw_erc1155(ctx, erc1155_req).await,
         WithdrawNftReq::WithdrawErc721(erc721_req) => withdraw_erc721(ctx, erc721_req).await,
     }
 }
@@ -265,3 +267,21 @@ async fn send_moralis_request(uri: &str, api_key: &str) -> MmResult<Json, GetNft
     let response: Json = try_or!(serde_json::from_str(&response_str), InvalidResponse);
     Ok(response)
 }
+
+/// This function uses `get_nft_list` method to get the correct info about amount of specific NFT owned by my_address.
+pub(crate) async fn find_wallet_amount(
+    ctx: MmArc,
+    nft_list: NftListReq,
+    token_address_req: String,
+    token_id_req: BigDecimal,
+) -> MmResult<BigDecimal, GetNftInfoError> {
+    let nft_list = get_nft_list(ctx, nft_list).await?.nfts;
+    let nft = nft_list
+        .into_iter()
+        .find(|nft| nft.token_address == token_address_req && nft.token_id == token_id_req)
+        .ok_or_else(|| GetNftInfoError::TokenNotFoundInWallet {
+            token_address: token_address_req,
+            token_id: token_id_req.to_string(),
+        })?;
+    Ok(nft.amount)
+}

mm2src/coins/nft/nft_errors.rs

@@ -7,7 +7,7 @@ use mm2_net::transport::SlurpError;
 use serde::{Deserialize, Serialize};
 use web3::Error;
 
-#[derive(Debug, Deserialize, Display, EnumFromStringify, Serialize, SerializeErrorType)]
+#[derive(Clone, Debug, Deserialize, Display, EnumFromStringify, PartialEq, Serialize, SerializeErrorType)]
 #[serde(tag = "error_type", content = "error_data")]
 pub enum GetNftInfoError {
     /// `http::Error` can appear on an HTTP request [`http::Builder::build`] building.
@@ -24,6 +24,15 @@ pub enum GetNftInfoError {
     GetEthAddressError(GetEthAddressError),
     #[display(fmt = "X-API-Key is missing")]
     ApiKeyError,
+    #[display(
+        fmt = "Token: token_address {}, token_id {} was not find in wallet",
+        token_address,
+        token_id
+    )]
+    TokenNotFoundInWallet {
+        token_address: String,
+        token_id: String,
+    },
 }
 
 impl From<SlurpError> for GetNftInfoError {
@@ -60,9 +69,10 @@ impl HttpStatusCode for GetNftInfoError {
             GetNftInfoError::InvalidRequest(_) => StatusCode::BAD_REQUEST,
             GetNftInfoError::InvalidResponse(_) => StatusCode::FAILED_DEPENDENCY,
             GetNftInfoError::ApiKeyError => StatusCode::FORBIDDEN,
-            GetNftInfoError::Transport(_) | GetNftInfoError::Internal(_) | GetNftInfoError::GetEthAddressError(_) => {
-                StatusCode::INTERNAL_SERVER_ERROR
-            },
+            GetNftInfoError::Transport(_)
+            | GetNftInfoError::Internal(_)
+            | GetNftInfoError::GetEthAddressError(_)
+            | GetNftInfoError::TokenNotFoundInWallet { .. } => StatusCode::INTERNAL_SERVER_ERROR,
         }
     }
 }