feat(torii): add world block and instrument queries

crates/torii/core/src/engine.rs

@@ -323,7 +323,7 @@
     pub async fn fetch_data(&mut self, cursors: &Cursors) -> Result<FetchDataResult> {
         let latest_block = self.provider.block_hash_and_number().await?;
 
-        let from = cursors.head.unwrap_or(0);
+        let from = cursors.head.unwrap_or(948000);
         let total_remaining_blocks = latest_block.block_number - from;
         let blocks_to_process = total_remaining_blocks.min(self.config.blocks_chunk_size);
         let to = from + blocks_to_process;

crates/torii/grpc/src/server/mod.rs

@@ -263,25 +263,36 @@
         dont_include_hashed_keys: bool,
         order_by: Option<&str>,
     ) -> Result<Vec<proto::types::Entity>, Error> {
+        tracing::debug!(
+            "Fetching entities from table {table} with {} entity/model pairs",
+            entities.len()
+        );
+        let start = std::time::Instant::now();
+
         // Group entities by their model combinations
         let mut model_groups: HashMap<String, Vec<String>> = HashMap::new();
         for (entity_id, models_str) in entities {
             model_groups.entry(models_str).or_default().push(entity_id);
         }
+        tracing::debug!("Grouped into {} distinct model combinations", model_groups.len());
 
         let mut all_entities = Vec::new();
 
         let mut tx = self.pool.begin().await?;
+        tracing::debug!("Started database transaction");
 
         // Create a temporary table to store entity IDs due to them potentially exceeding
         // SQLite's parameters limit which is 999
+        let temp_table_start = std::time::Instant::now();
         sqlx::query(
             "CREATE TEMPORARY TABLE temp_entity_ids (id TEXT PRIMARY KEY, model_group TEXT)",
         )
         .execute(&mut *tx)
         .await?;
+        tracing::debug!("Created temporary table in {:?}", temp_table_start.elapsed());
 
         // Insert all entity IDs into the temporary table
+        let insert_start = std::time::Instant::now();
         for (model_ids, entity_ids) in &model_groups {
             for chunk in entity_ids.chunks(999) {
                 let placeholders = chunk.iter().map(|_| "(?, ?)").collect::<Vec<_>>().join(",");
@@ -296,8 +307,14 @@
                 query.execute(&mut *tx).await?;
             }
         }
+        tracing::debug!(
+            "Inserted all entity IDs into temporary table in {:?}",
+            insert_start.elapsed()
+        );
 
-        for (models_str, _) in model_groups {
+        let query_start = std::time::Instant::now();
+        for (models_str, entity_ids) in &model_groups {
+            tracing::debug!("Processing model group with {} entities", entity_ids.len());
             let model_ids =
                 models_str.split(',').map(|id| Felt::from_str(id).unwrap()).collect::<Vec<_>>();
             let schemas =
@@ -325,10 +342,15 @@
 
             all_entities.extend(group_entities?);
         }
+        tracing::debug!("Processed all model groups in {:?}", query_start.elapsed());
 
         sqlx::query("DROP TABLE temp_entity_ids").execute(&mut *tx).await?;
+        tracing::debug!("Dropped temporary table");
 
         tx.commit().await?;
+        tracing::debug!("Committed transaction");
+
+        tracing::debug!("Total fetch_entities operation took {:?}", start.elapsed());
 
         Ok(all_entities)
     }

eternum.toml

@@ -0,0 +1,13 @@
+world_address = "0x6a9e4c6f0799160ea8ddc43ff982a5f83d7f633e9732ce42701de1288ff705f"
+rpc = "https://api.cartridge.gg/x/starknet/mainnet"
+explorer = false
+
+[indexing]
+events_chunk_size = 1024
+blocks_chunk_size = 1024000
+pending = true
+polling_interval = 500
+max_concurrent_tasks = 100
+transactions = false
+contracts = ["ERC721:0x57675b9c0bd62b096a2e15502a37b290fa766ead21c33eda42993e48a714b80", "ERC721:0x7ae27a31bb6526e3de9cf02f081f6ce0615ac12a6d7b85ee58b8ad7947a2809", "ERC20:0x124aeb495b947201f5fac96fd1138e326ad86195b98df6dec9009158a533b49"]
+namespaces = []