feat: add collection whitelist

Author: mickvandijke

Cargo.lock

@@ -15,3 +15,4 @@ thiserror = "1.0"
 tokio = { version = "1", features = ["rt-multi-thread"] }
 tracing-subscriber = "0.3.18"
 reqwest = "0.12.4"
+log = "0.4.21"

Cargo.toml

@@ -1,143 +1 @@
-[
-  {
-    "anonymous": false,
-    "inputs": [
-      {
-        "indexed": true,
-        "internalType": "address",
-        "name": "walletAddress",
-        "type": "address"
-      },
-      {
-        "indexed": true,
-        "internalType": "address",
-        "name": "tokenAddress",
-        "type": "address"
-      },
-      {
-        "indexed": true,
-        "internalType": "uint256",
-        "name": "tokenId",
-        "type": "uint256"
-      }
-    ],
-    "name": "AvatarSet",
-    "type": "event"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "",
-        "type": "address"
-      }
-    ],
-    "name": "avatars",
-    "outputs": [
-      {
-        "internalType": "address",
-        "name": "tokenAddress",
-        "type": "address"
-      },
-      {
-        "internalType": "uint256",
-        "name": "tokenId",
-        "type": "uint256"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "walletAddress",
-        "type": "address"
-      }
-    ],
-    "name": "getAvatar",
-    "outputs": [
-      {
-        "components": [
-          {
-            "internalType": "address",
-            "name": "tokenAddress",
-            "type": "address"
-          },
-          {
-            "internalType": "uint256",
-            "name": "tokenId",
-            "type": "uint256"
-          }
-        ],
-        "internalType": "struct AvatarService.Avatar",
-        "name": "",
-        "type": "tuple"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "walletAddress",
-        "type": "address"
-      }
-    ],
-    "name": "getAvatarInfo",
-    "outputs": [
-      {
-        "components": [
-          {
-            "components": [
-              {
-                "internalType": "address",
-                "name": "tokenAddress",
-                "type": "address"
-              },
-              {
-                "internalType": "uint256",
-                "name": "tokenId",
-                "type": "uint256"
-              }
-            ],
-            "internalType": "struct AvatarService.Avatar",
-            "name": "avatar",
-            "type": "tuple"
-          },
-          {
-            "internalType": "bool",
-            "name": "owned",
-            "type": "bool"
-          }
-        ],
-        "internalType": "struct AvatarService.AvatarInfo",
-        "name": "",
-        "type": "tuple"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "tokenAddress",
-        "type": "address"
-      },
-      {
-        "internalType": "uint256",
-        "name": "tokenId",
-        "type": "uint256"
-      }
-    ],
-    "name": "setAvatar",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  }
-]
+[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"walletAddress","type":"address"},{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"AvatarSet","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"avatars","outputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"walletAddress","type":"address"}],"name":"getAvatar","outputs":[{"components":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"internalType":"struct AvatarService.Avatar","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"walletAddress","type":"address"}],"name":"getAvatarInfo","outputs":[{"components":[{"components":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"internalType":"struct AvatarService.Avatar","name":"avatar","type":"tuple"},{"internalType":"bool","name":"owned","type":"bool"},{"internalType":"string","name":"uri","type":"string"}],"internalType":"struct AvatarService.AvatarInfo","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"setAvatar","outputs":[],"stateMutability":"nonpayable","type":"function"}]

abi/AvatarService.json

@@ -1,14 +1,16 @@
+use std::sync::Arc;
+use axum::extract::State;
 use axum::Json;
 
 use crate::extractors::ethereum_address::EthereumAddress;
 use crate::response::avatar::AvatarInfoWithMetadataResponse;
 use crate::response::error::AppResult;
-use crate::services;
+use crate::services::avatar::AvatarService;
 use crate::supported_networks::SupportedNetworks;
 
 #[allow(clippy::missing_errors_doc)]
-pub async fn get(EthereumAddress(address): EthereumAddress, ) -> AppResult<Json<AvatarInfoWithMetadataResponse>> {
-    let response = services::avatar::get_info_with_metadata(&address, SupportedNetworks::all()).await?;
+pub async fn get(State(avatar_service): State<Arc<AvatarService>>, EthereumAddress(address): EthereumAddress) -> AppResult<Json<AvatarInfoWithMetadataResponse>> {
+    let response = avatar_service.get_info_with_metadata(&address, SupportedNetworks::all()).await?;
 
     Ok(Json(response))
 }

src/handlers/avatar.rs

@@ -1 +1,2 @@
-pub mod avatar;
+pub mod avatar;
+pub mod whitelist;

src/handlers/mod.rs

@@ -0,0 +1,18 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use alloy::primitives::Address;
+use axum::extract::State;
+use axum::Json;
+
+use crate::models::avatar::AvatarCollection;
+use crate::response::error::AppResult;
+use crate::services::avatar::AvatarService;
+use crate::supported_networks::SupportedNetworks;
+
+#[allow(clippy::missing_errors_doc)]
+pub async fn get(State(avatar_service): State<Arc<AvatarService>>) -> AppResult<Json<HashMap<SupportedNetworks, HashMap<Address, AvatarCollection>>>> {
+    let response = avatar_service.cache.verified_collections.read().await.clone();
+
+    Ok(Json(response))
+}

src/handlers/whitelist.rs

@@ -1,19 +1,29 @@
+use std::sync::Arc;
 use axum::{
     routing::get,
     Router,
 };
 use dotenv::dotenv;
 
 use eas_api::handlers;
+use eas_api::services::avatar::AvatarService;
 
 #[tokio::main]
 async fn main() {
     dotenv().ok();
 
     // initialize tracing
     tracing_subscriber::fmt::init();
+    
+    let avatar_service = Arc::new(AvatarService::new());
+    
+    // Load verified collections from GitHub: https://github.com/ethereum-avatar-service/eas-api-whitelist
+    avatar_service.reload_verified_collections().await;
 
-    let app = Router::new().route("/avatar/:wallet_address", get(handlers::avatar::get));
+    let app = Router::new()
+        .route("/avatar/:wallet_address", get(handlers::avatar::get))
+        .route("/whitelist", get(handlers::whitelist::get))
+        .with_state(avatar_service);
 
     let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
     axum::serve(listener, app).await.unwrap();

src/main.rs

@@ -43,14 +43,22 @@ impl From<services::rpc::AvatarService::AvatarInfo> for AvatarInfo {
 }
 
 #[allow(clippy::module_name_repetitions)]
-#[derive(Serialize)]
-pub struct AvatarMetadata {
-    pub image: String,
+#[derive(Serialize, Clone)]
+pub struct AvatarCollection {
+    pub name: Option<String>,
     pub author: Option<String>,
     pub website: Option<String>,
+    pub opensea: Option<String>,
     pub verified: bool
 }
 
+#[allow(clippy::module_name_repetitions)]
+#[derive(Serialize)]
+pub struct AvatarMetadata {
+    pub image: String,
+    pub collection: Option<AvatarCollection>
+}
+
 #[allow(clippy::module_name_repetitions)]
 #[derive(Serialize)]
 pub struct AvatarInfoWithMetadata {

src/models/avatar.rs

@@ -1,2 +1,3 @@
 pub mod avatar;
-pub mod nft;
+pub mod nft;
+pub mod whitelist;

src/models/mod.rs

@@ -0,0 +1,15 @@
+use std::collections::HashMap;
+
+use serde::Deserialize;
+
+#[derive(Deserialize, Debug)]
+pub struct Collection {
+    pub contract: String,
+    pub name: String,
+    pub author: String,
+    pub website: String,
+    pub opensea: Option<String>
+}
+
+#[derive(Deserialize, Debug)]
+pub struct Collections(pub HashMap<String, Vec<Collection>>);

src/models/whitelist.rs

@@ -1,29 +1,92 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
 use alloy::primitives::Address;
+use tokio::sync::RwLock;
 
+use crate::models::avatar::AvatarCollection;
+use crate::models::whitelist;
 use crate::response::avatar::AvatarInfoWithMetadataResponse;
 use crate::services::rpc;
 use crate::supported_networks::SupportedNetworks;
 
-#[allow(clippy::missing_errors_doc)]
-#[allow(clippy::missing_panics_doc)]
-pub async fn get_info_with_metadata(address: &Address, networks: impl IntoIterator<Item =SupportedNetworks>) -> eyre::Result<AvatarInfoWithMetadataResponse> {
-    let mut response = AvatarInfoWithMetadataResponse::default();
-
-    let networks: Vec<SupportedNetworks> = networks.into_iter().collect();
+#[allow(clippy::module_name_repetitions)]
+pub struct AvatarServiceCache {
+    pub verified_collections: RwLock<HashMap<SupportedNetworks, HashMap<Address, AvatarCollection>>>
+}
 
-    if networks.contains(&SupportedNetworks::Sepolia) {
-        let provider = rpc::sepolia::new();
-        let maybe_avatar_info = provider.get_avatar_info_with_metadata(address).await.ok();
+#[allow(clippy::module_name_repetitions)]
+pub struct AvatarService {
+    pub cache: Arc<AvatarServiceCache>
+}
 
-        response.networks.insert("sepolia".to_string(), maybe_avatar_info);
+impl AvatarService {
+    pub fn new() -> Self {
+        Self {
+            cache: Arc::new(AvatarServiceCache {
+                verified_collections: RwLock::default()
+            }),
+        }
     }
 
-    if networks.contains(&SupportedNetworks::Polygon) {
-        let provider = rpc::polygon::new();
-        let maybe_avatar_info = provider.get_avatar_info_with_metadata(address).await.ok();
-        
-        response.networks.insert("polygon".to_string(), maybe_avatar_info);
+    pub async fn reload_verified_collections(&self) {
+        let result = reqwest::get("https://raw.githubusercontent.com/ethereum-avatar-service/eas-api-whitelist/main/collections.json").await;
+
+        let mut verified_collections = self.cache.verified_collections.write().await;
+
+        if let Ok(response) = result {
+            match response.json::<whitelist::Collections>().await {
+                Ok(collections) => {
+                    for (network, network_collections) in collections.0 {
+                        for collection in network_collections {
+                            if let Ok(address) = collection.contract.parse::<Address>() {
+                                let chain = match network.to_lowercase().as_str() {
+                                    "sepolia" => SupportedNetworks::Sepolia,
+                                    "polygon" => SupportedNetworks::Polygon,
+                                    _ => { continue; }
+                                };
+
+                                let entry = verified_collections.entry(chain).or_default();
+
+                                entry.insert(address, AvatarCollection {
+                                    name: Some(collection.name.to_string()),
+                                    author: Some(collection.author.to_string()),
+                                    website: Some(collection.website.to_string()),
+                                    opensea: collection.opensea.clone(),
+                                    verified: true,
+                                });
+                            }
+                        }
+                    }
+                }
+                Err(err) => {
+                    println!("{err}");
+                }
+            }
+        }
     }
 
-    Ok(response)
+    #[allow(clippy::missing_errors_doc)]
+    #[allow(clippy::missing_panics_doc)]
+    pub async fn get_info_with_metadata(&self, address: &Address, networks: impl IntoIterator<Item=SupportedNetworks>) -> eyre::Result<AvatarInfoWithMetadataResponse> {
+        let mut response = AvatarInfoWithMetadataResponse::default();
+
+        let networks: Vec<SupportedNetworks> = networks.into_iter().collect();
+
+        if networks.contains(&SupportedNetworks::Sepolia) {
+            let provider = rpc::sepolia::new();
+            let maybe_avatar_info = provider.get_avatar_info_with_metadata(address, self.cache.clone()).await.ok();
+
+            response.networks.insert("sepolia".to_string(), maybe_avatar_info);
+        }
+
+        if networks.contains(&SupportedNetworks::Polygon) {
+            let provider = rpc::polygon::new();
+            let maybe_avatar_info = provider.get_avatar_info_with_metadata(address, self.cache.clone()).await.ok();
+
+            response.networks.insert("polygon".to_string(), maybe_avatar_info);
+        }
+
+        Ok(response)
+    }
 }