add token manager logic

crates/ark-starknet/src/client2.rs

@@ -119,7 +119,8 @@ impl StarknetClient {
         Ok(events)
     }
 
-    ///
+    /// Call a contract trying all the given selectors.
+    /// All selector must accept the same arguments.
     pub async fn call_contract(
         &self,
         contract_address: FieldElement,

src/main.rs

@@ -1,23 +1,21 @@
 mod constants;
 mod contract;
 mod managers;
+mod storage;
 mod transfer;
 mod utils;
 
 use anyhow::Result;
 use ark_starknet::client2::StarknetClient;
 use dotenv::dotenv;
 use managers::collection_manager::ContractType;
-use managers::{BlockManager, CollectionManager, EventManager};
+use managers::{BlockManager, CollectionManager, EventManager, TokenManager};
+use starknet::core::types::*;
 use std::env;
+use tokio::time::{self, Duration};
 use tracing::{span, Level};
 use tracing_subscriber::{fmt, layer::SubscriberExt, EnvFilter, Registry};
 
-use starknet::core::types::*;
-use tokio::time::{self, Duration};
-
-mod storage;
-
 #[tokio::main]
 async fn main() -> Result<()> {
     dotenv().ok();
@@ -29,6 +27,7 @@ async fn main() -> Result<()> {
     let storage = storage::init_default();
     let block_manager = BlockManager::new(&storage, &sn_client);
     let mut event_manager = EventManager::new(&storage, &sn_client);
+    let mut token_manager = TokenManager::new(&storage, &sn_client);
     let mut collection_manager = CollectionManager::new(&storage, &sn_client);
 
     let (from_block, to_block, poll_head_of_chain) = block_manager.get_block_range();
@@ -76,13 +75,7 @@ async fn main() -> Result<()> {
                     continue;
                 }
 
-                log::debug!(
-                    "Contract type [{:#064x}] : {}",
-                    contract_address,
-                    contract_type.to_string()
-                );
-
-                let _token_id = match event_manager
+                let token_event = match event_manager
                     .format_event(&e, contract_type, block_ts)
                     .await
                 {
@@ -93,7 +86,13 @@ async fn main() -> Result<()> {
                     }
                 };
 
-                // token_manager.register_token(...);
+                match token_manager.format_token(&token_event).await {
+                    Ok(()) => (),
+                    Err(err) => {
+                        log::error!("Can't format token {:?}\ntevent: {:?}", err, token_event);
+                        continue;
+                    }
+                }
             }
         }
 
@@ -126,7 +125,7 @@ async fn check_range(
             .await
             .expect("Can't fetch last block number");
     } else {
-        return current;
+        return to;
     }
 }
 

src/managers/collection_manager.rs

@@ -1,11 +1,11 @@
 use anyhow::{anyhow, Result};
 use ark_starknet::client2::StarknetClient;
 use ark_storage::storage_manager::StorageManager;
-use log::info;
+
 use serde::{Deserialize, Serialize};
 use starknet::core::types::{BlockId, BlockTag, FieldElement};
 use starknet::core::utils::{get_selector_from_name, parse_cairo_short_string};
-use starknet::macros::selector;
+
 use std::collections::HashMap;
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
@@ -74,6 +74,12 @@ impl<'a, T: StorageManager> CollectionManager<'a, T> {
                 // Can't find info, try to identify with calls.
                 let contract_type = self.get_contract_type(address).await?;
 
+                log::debug!(
+                    "Contract type [{:#064x}] : {}",
+                    address,
+                    contract_type.to_string()
+                );
+
                 let info = ContractInfo {
                     name: String::new(),
                     symbol: String::new(),
@@ -82,61 +88,12 @@ impl<'a, T: StorageManager> CollectionManager<'a, T> {
 
                 self.cache.insert(address, info.clone());
                 // TODO: self.storage.register_contract_info(...);
+
                 Ok(info)
             }
         }
     }
 
-    pub async fn get_token_owner(
-        &self,
-        contract_address: FieldElement,
-        token_id_low: FieldElement,
-        token_id_high: FieldElement,
-    ) -> Result<Vec<FieldElement>> {
-        let block = BlockId::Tag(BlockTag::Latest);
-
-        match self
-            .client
-            .call_contract(
-                contract_address,
-                selector!("owner_of"),
-                vec![token_id_low, token_id_high],
-                block,
-            )
-            .await
-        {
-            Ok(res) => Ok(res),
-            Err(_) => self
-                .client
-                .call_contract(
-                    contract_address,
-                    selector!("owner_of"),
-                    vec![token_id_low, token_id_high],
-                    block,
-                )
-                .await
-                .map_err(|_| anyhow!("Failed to get token owner")),
-        }
-    }
-
-    async fn call_contract_helper(
-        &self,
-        contract_address: FieldElement,
-        selector_name: &str,
-        token_id_low: FieldElement,
-        token_id_high: FieldElement,
-        block_id: BlockId,
-    ) -> Result<Vec<FieldElement>> {
-        self.client
-            .call_contract(
-                contract_address,
-                get_selector_from_name(selector_name)?,
-                vec![token_id_low, token_id_high],
-                block_id,
-            )
-            .await
-    }
-
     pub async fn get_contract_type(&self, contract_address: FieldElement) -> Result<ContractType> {
         let block = BlockId::Tag(BlockTag::Latest);
         let token_uri_cairo_0 = self
@@ -182,8 +139,6 @@ impl<'a, T: StorageManager> CollectionManager<'a, T> {
         calldata: Vec<FieldElement>,
         block: BlockId,
     ) -> Result<String> {
-        info!("Getting contract property: {:?}", selector_name);
-
         let response = self
             .client
             .call_contract(

src/managers/event_manager.rs

@@ -39,7 +39,7 @@ impl<'a, T: StorageManager> EventManager<'a, T> {
         event: &EmittedEvent,
         contract_type: ContractType,
         timestamp: u64,
-    ) -> Result<TokenId> {
+    ) -> Result<TokenEvent> {
         self.reset_event();
 
         // As cairo didn't have keys before, we first check if the data
@@ -75,7 +75,7 @@ impl<'a, T: StorageManager> EventManager<'a, T> {
         // TODO: self.storage.register_event(self.token_event);
         // TODO: check depending on event type if it's a create/update etc...?
 
-        Ok(token_id)
+        Ok(self.token_event.clone())
     }
 
     pub fn get_event_type(from: FieldElement, to: FieldElement) -> EventType {

src/managers/token_manager.rs

@@ -1,34 +1,38 @@
-use anyhow::Result;
+use anyhow::{anyhow, Result};
+use ark_starknet::client2::StarknetClient;
 use ark_storage::storage_manager::StorageManager;
 use ark_storage::types::{EventType, TokenEvent, TokenFromEvent};
+use starknet::core::types::*;
+use starknet::macros::selector;
 
 #[derive(Debug)]
 pub struct TokenManager<'a, T: StorageManager> {
     storage: &'a T,
+    client: &'a StarknetClient,
+    // TODO: Same as event manager, we should use the stack instead.
+    // check with @kwiss.
     token: TokenFromEvent,
-    // client: StarknetClient,
 }
 
 impl<'a, T: StorageManager> TokenManager<'a, T> {
-    pub fn new(
-        storage: &'a T,
-        // client: StarknetClient
-    ) -> Self {
+    /// Initializes a new instance.
+    pub fn new(storage: &'a T, client: &'a StarknetClient) -> Self {
         Self {
             storage,
+            client,
             token: TokenFromEvent::default(),
-            // client
         }
     }
 
-    pub fn format_token_from_event(&mut self, event: &TokenEvent) {
+    /// Formats a token registry from the token event data.
+    pub async fn format_token(&mut self, event: &TokenEvent) -> Result<()> {
+        self.reset_token();
+
         self.token.address = event.contract_address.clone();
         self.token.padded_token_id = event.padded_token_id.clone();
         self.token.from_address = event.from_address.clone();
         self.token.to_address = event.to_address.clone();
         self.token.timestamp = event.timestamp.clone();
-        // TODO update owner here call get_token_owner
-        self.token.owner = event.to_address.clone();
         self.token.mint_transaction_hash = if event.event_type == EventType::Mint {
             Some(event.transaction_hash.clone())
         } else {
@@ -39,26 +43,66 @@ impl<'a, T: StorageManager> TokenManager<'a, T> {
         } else {
             None
         };
-    }
 
-    pub fn create_token(&self) -> Result<()> {
-        self.storage.create_token(&self.token);
+        // TODO: @kwiss, do we want a default value in case we can't get the token owner?
+        // or do we want to return an error and abort before saving in the storage?
+        let token_owner = self
+            .get_token_owner(
+                FieldElement::from_hex_be(&event.contract_address)
+                    .expect("Contract address bad format"),
+                FieldElement::from(event.token_id.low),
+                FieldElement::from(event.token_id.high),
+            )
+            .await?[0];
+
+        self.token.owner = format!("{:#064x}", token_owner);
+
+        log::trace!(
+            "Registering token: {} {}",
+            event.token_id.format().token_id,
+            event.contract_address
+        );
+
+        // TODO: self.storage.register_token(self.token.clone()).await?;
+
         Ok(())
     }
 
+    ///
     pub fn reset_token(&mut self) {
         self.token = TokenFromEvent::default();
     }
 
-    // pub fn get_token_owner(&self) -> TokenFromEvent {
-    //     TODO call contract to get owner
-    // }
+    /// Retrieves the token owner for the last block.
+    pub async fn get_token_owner(
+        &self,
+        contract_address: FieldElement,
+        token_id_low: FieldElement,
+        token_id_high: FieldElement,
+    ) -> Result<Vec<FieldElement>> {
+        let block = BlockId::Tag(BlockTag::Latest);
 
-    // pub fn update_token_owner(&self) -> Result<()> {
-    //     let token = self
-    //         .storage
-    //         .get_token(event.contract_address.clone(), event.token_id.clone())?;
-    //     self.storage.update_token_owner(&token);
-    //     Ok(())
-    // }
+        match self
+            .client
+            .call_contract(
+                contract_address,
+                selector!("owner_of"),
+                vec![token_id_low, token_id_high],
+                block,
+            )
+            .await
+        {
+            Ok(res) => Ok(res),
+            Err(_) => self
+                .client
+                .call_contract(
+                    contract_address,
+                    selector!("ownerOf"),
+                    vec![token_id_low, token_id_high],
+                    block,
+                )
+                .await
+                .map_err(|_| anyhow!("Failed to get token owner from chain")),
+        }
+    }
 }