feat(torii-indexer): transaction calls and outside calls

crates/torii/migrations/20250307134638_transaction-calls.sql

@@ -0,0 +1,5 @@
+-- We parse the calls from the transaction calldata
+-- and outside calls from for eg. paymaster transactions
+ALTER TABLE transactions 
+ADD COLUMN outside_calls TEXT
+ADD COLUMN calls TEXT

crates/torii/sqlite/src/cache.rs

@@ -3,8 +3,11 @@ use std::collections::{HashMap, HashSet};
 use dojo_types::schema::Ty;
 use dojo_world::contracts::abigen::model::Layout;
 use sqlx::{Pool, Sqlite, SqlitePool};
+use starknet::core::types::{BlockId, BlockTag, ContractClass};
+use starknet::providers::Provider;
 use starknet_crypto::Felt;
 use tokio::sync::RwLock;
+use std::sync::Arc;
 
 use crate::constants::TOKEN_BALANCE_TABLE;
 use crate::error::{Error, ParseError};
@@ -147,3 +150,30 @@ impl LocalCache {
         self.token_id_registry.write().await.insert(token_id);
     }
 }
+
+#[derive(Debug)]
+pub struct ContractClassCache<P: Provider + Send + Sync + std::fmt::Debug + 'static> {
+    pub classes: RwLock<HashMap<Felt, (Felt, ContractClass)>>,
+    pub provider: Arc<P>,
+}
+
+impl<P: Provider + Send + Sync + std::fmt::Debug + 'static> ContractClassCache<P> {
+    pub fn new(provider: Arc<P>) -> Self {
+        Self {
+            classes: RwLock::new(HashMap::new()),
+            provider,
+        }
+    }
+
+    pub async fn get(&self, contract_address: Felt, block_id: BlockId) -> Result<ContractClass, Error> {
+        let classes = self.classes.read().await;
+        if let Some(class) = classes.get(&contract_address) {
+            return Ok(class.1.clone());
+        }
+
+        let class_hash = self.provider.get_class_hash_at(block_id, contract_address).await.unwrap();
+        let class = self.provider.get_class(block_id, class_hash).await.unwrap();
+        self.classes.write().await.insert(contract_address, (class_hash, class.clone()));
+        Ok(class)
+    }
+}

crates/torii/sqlite/src/lib.rs

@@ -11,7 +11,7 @@ use dojo_world::config::WorldMetadata;
 use dojo_world::contracts::abigen::model::Layout;
 use dojo_world::contracts::naming::compute_selector_from_names;
 use sqlx::{Pool, Sqlite};
-use starknet::core::types::{Event, Felt, InvokeTransaction, Transaction};
+use starknet::core::types::{Call, Event, Felt, InvokeTransaction, Transaction};
 use starknet_crypto::poseidon_hash_many;
 use tokio::sync::mpsc::UnboundedSender;
 use utils::felts_to_sql_string;
@@ -520,30 +520,33 @@ impl Sql {
                 Transaction::Invoke(InvokeTransaction::V3(invoke_v3_transaction)) => (
                     Argument::FieldElement(invoke_v3_transaction.transaction_hash),
                     Argument::FieldElement(invoke_v3_transaction.sender_address),
-                    Argument::String(felts_to_sql_string(&invoke_v3_transaction.calldata)),
+                    &invoke_v3_transaction.calldata,
                     Argument::FieldElement(Felt::ZERO), // has no max_fee
                     Argument::String(felts_to_sql_string(&invoke_v3_transaction.signature)),
                     Argument::FieldElement(invoke_v3_transaction.nonce),
                 ),
                 Transaction::Invoke(InvokeTransaction::V1(invoke_v1_transaction)) => (
                     Argument::FieldElement(invoke_v1_transaction.transaction_hash),
                     Argument::FieldElement(invoke_v1_transaction.sender_address),
-                    Argument::String(felts_to_sql_string(&invoke_v1_transaction.calldata)),
+                    &invoke_v1_transaction.calldata,
                     Argument::FieldElement(invoke_v1_transaction.max_fee),
                     Argument::String(felts_to_sql_string(&invoke_v1_transaction.signature)),
                     Argument::FieldElement(invoke_v1_transaction.nonce),
                 ),
                 Transaction::L1Handler(l1_handler_transaction) => (
                     Argument::FieldElement(l1_handler_transaction.transaction_hash),
                     Argument::FieldElement(l1_handler_transaction.contract_address),
-                    Argument::String(felts_to_sql_string(&l1_handler_transaction.calldata)),
+                    &l1_handler_transaction.calldata,
                     Argument::FieldElement(Felt::ZERO), // has no max_fee
                     Argument::String("".to_string()),   // has no signature
                     Argument::FieldElement((l1_handler_transaction.nonce).into()),
                 ),
                 _ => return Ok(()),
             };
 
+        let num_calls = calldata[0];
+        let mut calls: Vec<Call> = vec![];
+
         self.executor.send(QueryMessage::other(
             "INSERT OR IGNORE INTO transactions (id, transaction_hash, sender_address, calldata, \
              max_fee, signature, nonce, transaction_type, executed_at, block_number) VALUES (?, \
@@ -553,7 +556,7 @@ impl Sql {
                 transaction_hash.clone(),
                 transaction_hash.clone(),
                 sender_address,
-                calldata,
+                Argument::String(felts_to_sql_string(&calldata)),
                 max_fee,
                 signature,
                 nonce,