feat(nft): db implementation (wasm target)

mm2src/coins/nft/nft_errors.rs

@@ -156,6 +156,10 @@ pub enum UpdateNftError {
     LastScannedBlockNotFound {
         last_nft_block: String,
     },
+    #[display(fmt = "Attempt to receive duplicate ERC721 token in transaction hash: {}", tx_hash)]
+    AttemptToReceiveAlreadyOwnedErc721 {
+        tx_hash: String,
+    },
 }
 
 impl From<CreateNftStorageError> for UpdateNftError {
@@ -188,7 +192,8 @@ impl HttpStatusCode for UpdateNftError {
             | UpdateNftError::TokenNotFoundInWallet { .. }
             | UpdateNftError::InsufficientAmountInCache { .. }
             | UpdateNftError::InvalidBlockOrder { .. }
-            | UpdateNftError::LastScannedBlockNotFound { .. } => StatusCode::INTERNAL_SERVER_ERROR,
+            | UpdateNftError::LastScannedBlockNotFound { .. }
+            | UpdateNftError::AttemptToReceiveAlreadyOwnedErc721 { .. } => StatusCode::INTERNAL_SERVER_ERROR,
         }
     }
 }

mm2src/coins/nft/nft_structs.rs

@@ -18,13 +18,17 @@ pub struct NftListReq {
     #[serde(default = "ten")]
     pub(crate) limit: usize,
     pub(crate) page_number: Option<NonZeroUsize>,
+    #[serde(default)]
+    pub(crate) protect_from_spam: bool,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct NftMetadataReq {
     pub(crate) token_address: Address,
     pub(crate) token_id: BigDecimal,
     pub(crate) chain: Chain,
+    #[serde(default)]
+    pub(crate) protect_from_spam: bool,
 }
 
 #[derive(Debug, Deserialize)]
@@ -128,14 +132,57 @@ impl fmt::Display for ContractType {
     }
 }
 
+/// `UriMeta` structure is the object which we create from `token_uri` and `metadata`.
+///
+/// `token_uri` and `metadata` usually contain either `image` or `image_url` with image url.
+/// But most often nft creators use only `image` name for this value (from my observation),
+/// less often they use both parameters with the same url.
+///
+/// I suspect this is because some APIs only look for one of these image url names, so nft creators try to satisfy all sides.
+/// In any case, since there is no clear standard, we have to look for both options,
+/// when we build `UriMeta` from `token_uri` or `metadata`.
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub(crate) struct UriMeta {
-    pub(crate) image: Option<String>,
-    #[serde(rename(deserialize = "name"))]
+    #[serde(rename = "image")]
+    pub(crate) raw_image_url: Option<String>,
+    pub(crate) image_url: Option<String>,
+    #[serde(rename = "name")]
     pub(crate) token_name: Option<String>,
-    description: Option<String>,
-    attributes: Option<Json>,
-    animation_url: Option<String>,
+    pub(crate) description: Option<String>,
+    pub(crate) attributes: Option<Json>,
+    pub(crate) animation_url: Option<String>,
+    pub(crate) external_url: Option<String>,
+    pub(crate) image_details: Option<Json>,
+}
+
+impl UriMeta {
+    /// `try_to_fill_missing_fields_from` function doesnt change `raw_image_url` field.
+    /// It tries to update `image_url` field instead, if it is None.
+    /// As `image` is the original name of `raw_image_url` field in data from `token_uri` or `metadata`,
+    /// try to find **Some()** in this field first.
+    pub(crate) fn try_to_fill_missing_fields_from(&mut self, other: UriMeta) {
+        if self.image_url.is_none() {
+            self.image_url = other.raw_image_url.or(other.image_url);
+        }
+        if self.token_name.is_none() {
+            self.token_name = other.token_name;
+        }
+        if self.description.is_none() {
+            self.description = other.description;
+        }
+        if self.attributes.is_none() {
+            self.attributes = other.attributes;
+        }
+        if self.animation_url.is_none() {
+            self.animation_url = other.animation_url;
+        }
+        if self.external_url.is_none() {
+            self.external_url = other.external_url;
+        }
+        if self.image_details.is_none() {
+            self.image_details = other.image_details;
+        }
+    }
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
@@ -145,8 +192,8 @@ pub struct Nft {
     pub(crate) token_id: BigDecimal,
     pub(crate) amount: BigDecimal,
     pub(crate) owner_of: String,
-    pub(crate) token_hash: String,
-    pub(crate) block_number_minted: u64,
+    pub(crate) token_hash: Option<String>,
+    pub(crate) block_number_minted: Option<u64>,
     pub(crate) block_number: u64,
     pub(crate) contract_type: ContractType,
     pub(crate) collection_name: Option<String>,
@@ -156,7 +203,7 @@ pub struct Nft {
     pub(crate) last_token_uri_sync: Option<String>,
     pub(crate) last_metadata_sync: Option<String>,
     pub(crate) minter_address: Option<String>,
-    pub(crate) possible_spam: Option<bool>,
+    pub(crate) possible_spam: bool,
     pub(crate) uri_meta: UriMeta,
 }
 
@@ -168,8 +215,8 @@ pub(crate) struct NftWrapper {
     pub(crate) token_id: SerdeStringWrap<BigDecimal>,
     pub(crate) amount: SerdeStringWrap<BigDecimal>,
     pub(crate) owner_of: String,
-    pub(crate) token_hash: String,
-    pub(crate) block_number_minted: SerdeStringWrap<u64>,
+    pub(crate) token_hash: Option<String>,
+    pub(crate) block_number_minted: Option<SerdeStringWrap<u64>>,
     pub(crate) block_number: SerdeStringWrap<u64>,
     pub(crate) contract_type: Option<SerdeStringWrap<ContractType>>,
     pub(crate) name: Option<String>,
@@ -179,7 +226,8 @@ pub(crate) struct NftWrapper {
     pub(crate) last_token_uri_sync: Option<String>,
     pub(crate) last_metadata_sync: Option<String>,
     pub(crate) minter_address: Option<String>,
-    pub(crate) possible_spam: Option<bool>,
+    #[serde(default)]
+    pub(crate) possible_spam: bool,
 }
 
 #[derive(Debug)]
@@ -277,6 +325,8 @@ pub struct NftTransfersReq {
     #[serde(default = "ten")]
     pub(crate) limit: usize,
     pub(crate) page_number: Option<NonZeroUsize>,
+    #[serde(default)]
+    pub(crate) protect_from_spam: bool,
 }
 
 #[derive(Debug, Display)]
@@ -312,53 +362,55 @@ impl fmt::Display for TransferStatus {
     }
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct NftTransferHistory {
     pub(crate) chain: Chain,
     pub(crate) block_number: u64,
     pub(crate) block_timestamp: u64,
-    pub(crate) block_hash: String,
+    pub(crate) block_hash: Option<String>,
     /// Transaction hash in hexadecimal format
     pub(crate) transaction_hash: String,
-    pub(crate) transaction_index: u64,
-    pub(crate) log_index: u64,
-    pub(crate) value: BigDecimal,
+    pub(crate) transaction_index: Option<u64>,
+    pub(crate) log_index: Option<u64>,
+    pub(crate) value: Option<BigDecimal>,
     pub(crate) contract_type: ContractType,
-    pub(crate) transaction_type: String,
+    pub(crate) transaction_type: Option<String>,
     pub(crate) token_address: String,
     pub(crate) token_id: BigDecimal,
+    pub(crate) token_uri: Option<String>,
     pub(crate) collection_name: Option<String>,
-    pub(crate) image: Option<String>,
+    pub(crate) image_url: Option<String>,
     pub(crate) token_name: Option<String>,
     pub(crate) from_address: String,
     pub(crate) to_address: String,
     pub(crate) status: TransferStatus,
     pub(crate) amount: BigDecimal,
-    pub(crate) verified: u64,
+    pub(crate) verified: Option<u64>,
     pub(crate) operator: Option<String>,
-    pub(crate) possible_spam: Option<bool>,
+    pub(crate) possible_spam: bool,
 }
 
 #[derive(Debug, Deserialize)]
 pub(crate) struct NftTransferHistoryWrapper {
     pub(crate) block_number: SerdeStringWrap<u64>,
     pub(crate) block_timestamp: String,
-    pub(crate) block_hash: String,
+    pub(crate) block_hash: Option<String>,
     /// Transaction hash in hexadecimal format
     pub(crate) transaction_hash: String,
-    pub(crate) transaction_index: u64,
-    pub(crate) log_index: u64,
-    pub(crate) value: SerdeStringWrap<BigDecimal>,
+    pub(crate) transaction_index: Option<u64>,
+    pub(crate) log_index: Option<u64>,
+    pub(crate) value: Option<SerdeStringWrap<BigDecimal>>,
     pub(crate) contract_type: Option<SerdeStringWrap<ContractType>>,
-    pub(crate) transaction_type: String,
+    pub(crate) transaction_type: Option<String>,
     pub(crate) token_address: String,
     pub(crate) token_id: SerdeStringWrap<BigDecimal>,
     pub(crate) from_address: String,
     pub(crate) to_address: String,
     pub(crate) amount: SerdeStringWrap<BigDecimal>,
-    pub(crate) verified: u64,
+    pub(crate) verified: Option<u64>,
     pub(crate) operator: Option<String>,
-    pub(crate) possible_spam: Option<bool>,
+    #[serde(default)]
+    pub(crate) possible_spam: bool,
 }
 
 #[derive(Debug, Serialize)]
@@ -368,11 +420,10 @@ pub struct NftsTransferHistoryList {
     pub(crate) total: usize,
 }
 
-#[allow(dead_code)]
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Copy, Clone, Debug, Deserialize)]
 pub struct NftTxHistoryFilters {
     #[serde(default)]
-    pub(crate) receive: bool,
+    pub receive: bool,
     #[serde(default)]
     pub(crate) send: bool,
     pub(crate) from_date: Option<u64>,
@@ -385,18 +436,18 @@ pub struct UpdateNftReq {
     pub(crate) url: Url,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, Eq, Hash, PartialEq)]
 pub struct NftTokenAddrId {
     pub(crate) token_address: String,
     pub(crate) token_id: BigDecimal,
 }
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub struct TxMeta {
     pub(crate) token_address: String,
     pub(crate) token_id: BigDecimal,
+    pub(crate) token_uri: Option<String>,
     pub(crate) collection_name: Option<String>,
-    pub(crate) image: Option<String>,
+    pub(crate) image_url: Option<String>,
     pub(crate) token_name: Option<String>,
 }

mm2src/coins/nft/nft_tests.rs

@@ -7,9 +7,40 @@ const TEST_WALLET_ADDR_EVM: &str = "0x394d86994f954ed931b86791b62fe64f4c5dac37";
 mod native_tests {
     use crate::nft::nft_structs::{NftTransferHistoryWrapper, NftWrapper, UriMeta};
     use crate::nft::nft_tests::{NFT_HISTORY_URL_TEST, NFT_LIST_URL_TEST, NFT_METADATA_URL_TEST, TEST_WALLET_ADDR_EVM};
-    use crate::nft::send_request_to_uri;
+    use crate::nft::storage::db_test_helpers::*;
+    use crate::nft::{check_and_redact_if_spam, check_moralis_ipfs_bafy, check_nft_metadata_for_spam,
+                     send_request_to_uri};
     use common::block_on;
 
+    #[test]
+    fn test_moralis_ipfs_bafy() {
+        let uri =
+            "https://ipfs.moralis.io:2053/ipfs/bafybeifnek24coy5xj5qabdwh24dlp5omq34nzgvazkfyxgnqms4eidsiq/1.json";
+        let res_uri = check_moralis_ipfs_bafy(Some(uri));
+        let expected = "https://ipfs.io/ipfs/bafybeifnek24coy5xj5qabdwh24dlp5omq34nzgvazkfyxgnqms4eidsiq/1.json";
+        assert_eq!(expected, res_uri.unwrap());
+    }
+
+    #[test]
+    fn test_invalid_moralis_ipfs_link() {
+        let uri = "example.com/bafy?1=ipfs.moralis.io&e=https://";
+        let res_uri = check_moralis_ipfs_bafy(Some(uri));
+        assert_eq!(uri, res_uri.unwrap());
+    }
+
+    #[test]
+    fn test_check_for_spam() {
+        let mut spam_text = Some("https://arweave.net".to_string());
+        assert!(check_and_redact_if_spam(&mut spam_text));
+        let url_redacted = "URL redacted for user protection";
+        assert_eq!(url_redacted, spam_text.unwrap());
+
+        let mut nft = nft();
+        assert!(check_nft_metadata_for_spam(&mut nft).unwrap());
+        let meta_redacted = "{\"name\":\"URL redacted for user protection\",\"image\":\"https://tikimetadata.s3.amazonaws.com/tiki_box.png\"}";
+        assert_eq!(meta_redacted, nft.metadata.unwrap())
+    }
+
     #[test]
     fn test_moralis_nft_list() {
         let response = block_on(send_request_to_uri(NFT_LIST_URL_TEST)).unwrap();
@@ -34,18 +65,52 @@ mod native_tests {
     fn test_moralis_nft_metadata() {
         let response = block_on(send_request_to_uri(NFT_METADATA_URL_TEST)).unwrap();
         let nft_wrapper: NftWrapper = serde_json::from_str(&response.to_string()).unwrap();
-        assert_eq!(41237364, *nft_wrapper.block_number_minted);
+        assert_eq!(41237364, *nft_wrapper.block_number_minted.unwrap());
         let token_uri = nft_wrapper.token_uri.unwrap();
         let uri_response = block_on(send_request_to_uri(token_uri.as_str())).unwrap();
         serde_json::from_str::<UriMeta>(&uri_response.to_string()).unwrap();
     }
+
+    #[test]
+    fn test_add_get_nfts() { block_on(test_add_get_nfts_impl()) }
+
+    #[test]
+    fn test_last_nft_blocks() { block_on(test_last_nft_blocks_impl()) }
+
+    #[test]
+    fn test_nft_list() { block_on(test_nft_list_impl()) }
+
+    #[test]
+    fn test_remove_nft() { block_on(test_remove_nft_impl()) }
+
+    #[test]
+    fn test_refresh_metadata() { block_on(test_refresh_metadata_impl()) }
+
+    #[test]
+    fn test_nft_amount() { block_on(test_nft_amount_impl()) }
+
+    #[test]
+    fn test_add_get_txs() { block_on(test_add_get_txs_impl()) }
+
+    #[test]
+    fn test_last_tx_block() { block_on(test_last_tx_block_impl()) }
+
+    #[test]
+    fn test_tx_history() { block_on(test_tx_history_impl()) }
+
+    #[test]
+    fn test_tx_history_filters() { block_on(test_tx_history_filters_impl()) }
+
+    #[test]
+    fn test_get_update_tx_meta() { block_on(test_get_update_tx_meta_impl()) }
 }
 
 #[cfg(target_arch = "wasm32")]
 mod wasm_tests {
     use crate::nft::nft_structs::{NftTransferHistoryWrapper, NftWrapper};
     use crate::nft::nft_tests::{NFT_HISTORY_URL_TEST, NFT_LIST_URL_TEST, NFT_METADATA_URL_TEST, TEST_WALLET_ADDR_EVM};
     use crate::nft::send_request_to_uri;
+    use crate::nft::storage::db_test_helpers::*;
     use wasm_bindgen_test::*;
 
     wasm_bindgen_test_configure!(run_in_browser);
@@ -74,6 +139,39 @@ mod wasm_tests {
     async fn test_moralis_nft_metadata() {
         let response = send_request_to_uri(NFT_METADATA_URL_TEST).await.unwrap();
         let nft_wrapper: NftWrapper = serde_json::from_str(&response.to_string()).unwrap();
-        assert_eq!(41237364, *nft_wrapper.block_number_minted);
+        assert_eq!(41237364, *nft_wrapper.block_number_minted.unwrap());
     }
+
+    #[wasm_bindgen_test]
+    async fn test_add_get_nfts() { test_add_get_nfts_impl().await }
+
+    #[wasm_bindgen_test]
+    async fn test_last_nft_blocks() { test_last_nft_blocks_impl().await }
+
+    #[wasm_bindgen_test]
+    async fn test_nft_list() { test_nft_list_impl().await }
+
+    #[wasm_bindgen_test]
+    async fn test_remove_nft() { test_remove_nft_impl().await }
+
+    #[wasm_bindgen_test]
+    async fn test_nft_amount() { test_nft_amount_impl().await }
+
+    #[wasm_bindgen_test]
+    async fn test_refresh_metadata() { test_refresh_metadata_impl().await }
+
+    #[wasm_bindgen_test]
+    async fn test_add_get_txs() { test_add_get_txs_impl().await }
+
+    #[wasm_bindgen_test]
+    async fn test_last_tx_block() { test_last_tx_block_impl().await }
+
+    #[wasm_bindgen_test]
+    async fn test_tx_history() { test_tx_history_impl().await }
+
+    #[wasm_bindgen_test]
+    async fn test_tx_history_filters() { test_tx_history_filters_impl().await }
+
+    #[wasm_bindgen_test]
+    async fn test_get_update_tx_meta() { test_get_update_tx_meta_impl().await }
 }