fix(torii): fallback invalid events & flag indexing pending blocks

bin/torii/src/main.rs

@@ -109,6 +109,10 @@
     /// Chunk size of the events page when indexing using events
     #[arg(long, default_value = "1000")]
     events_chunk_size: u64,
+
+    /// Enable indexing pending blocks
+    #[arg(long)]
+    index_pending: bool,
 }
 
 #[tokio::main]
@@ -179,6 +183,7 @@
         EngineConfig {
             start_block: args.start_block,
             events_chunk_size: args.events_chunk_size,
+            index_pending: args.index_pending,
             ..Default::default()
         },
         shutdown_tx.clone(),

crates/torii/core/src/engine.rs

@@ -37,11 +37,17 @@
     pub block_time: Duration,
     pub start_block: u64,
     pub events_chunk_size: u64,
+    pub index_pending: bool,
 }
 
 impl Default for EngineConfig {
     fn default() -> Self {
-        Self { block_time: Duration::from_secs(1), start_block: 0, events_chunk_size: 1000 }
+        Self {
+            block_time: Duration::from_secs(1),
+            start_block: 0,
+            events_chunk_size: 1000,
+            index_pending: false,
+        }
     }
 }
 
@@ -123,7 +129,7 @@
             // if `from` == 0, then the block may or may not be processed yet.
             let from = if from == 0 { from } else { from + 1 };
             pending_block_tx = self.sync_range(from, latest_block_number, pending_block_tx).await?;
-        } else {
+        } else if self.config.index_pending {
             pending_block_tx = self.sync_pending(latest_block_number + 1, pending_block_tx).await?;
         }
 
@@ -235,7 +241,22 @@
             for event in &events_page.events {
                 let block_number = match event.block_number {
                     Some(block_number) => block_number,
-                    None => return Err(anyhow::anyhow!("Event without block number.")),
+                    // If the block number is not present, try to fetch it from the transaction
+                    // receipt Should not/rarely happen. Thus the additional
+                    // fetch is acceptable.
+                    None => {
+                        match self.provider.get_transaction_receipt(event.transaction_hash).await? {
+                            MaybePendingTransactionReceipt::Receipt(
+                                TransactionReceipt::Invoke(receipt),
+                            ) => receipt.block_number,
+                            MaybePendingTransactionReceipt::Receipt(
+                                TransactionReceipt::L1Handler(receipt),
+                            ) => receipt.block_number,
+                            // If it's a pending transaction, we assume the block number is the
+                            // latest + 1
+                            _ => to + 1,
+                        }
+                    }
                 };
 
                 // Keep track of last block number and fetch block timestamp