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

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

* parse calls

* contract class cache

* c

* parsing native and outside calls

* support v2 and write db

* correct decoding of raw felts

* clean

* feat: add support to graphql

* f

* use transaction calls table instead

* add caller address for outisde exectuion and calls

* fix: correct caller address

* fetch entrypoints names

* fix send for class abo

* fix deadlock

* fix block not found error on pending

* only parse calldata for invoke tx

* offset ovr fns

* retrieving function name for legacy class

* use cainome

* add calls graphql

* token transfers from tx

* move tx to executro & broadcast

* trnsaction subscription

* f

* chore

* fix tx

* tx subscirption and block number

* fmt

* subscribe to have speicfic caller

* f

* c

* cleanup for merge

* f

* transaction c

* opt memroy footprint

* f

Author: Larkooo

Cargo.lock

@@ -8,6 +8,8 @@ pub const EVENT_TABLE: &str = "events";
 pub const EVENT_MESSAGE_TABLE: &str = "event_messages";
 pub const MODEL_TABLE: &str = "models";
 pub const TRANSACTION_TABLE: &str = "transactions";
+pub const TRANSACTION_CALLS_TABLE: &str = "transaction_calls";
+pub const TOKEN_TRANSFER_TABLE: &str = "token_transfers";
 pub const METADATA_TABLE: &str = "metadata";
 pub const CONTROLLER_TABLE: &str = "controllers";
 
@@ -30,6 +32,7 @@ pub const CONTENT_TYPE_NAME: &str = "World__Content";
 pub const METADATA_TYPE_NAME: &str = "World__Metadata";
 pub const PAGE_INFO_TYPE_NAME: &str = "World__PageInfo";
 pub const TRANSACTION_TYPE_NAME: &str = "World__Transaction";
+pub const CALL_TYPE_NAME: &str = "World__Call";
 pub const QUERY_TYPE_NAME: &str = "World__Query";
 pub const SUBSCRIPTION_TYPE_NAME: &str = "World__Subscription";
 pub const MODEL_ORDER_TYPE_NAME: &str = "World__ModelOrder";

crates/torii/graphql/src/constants.rs

@@ -64,6 +64,14 @@ lazy_static! {
             TypeData::Simple(TypeRef::named(GraphqlType::DateTime.to_string())),
         ),
     ]);
+    pub static ref CALL_MAPPING: TypeMapping = IndexMap::from([
+        (Name::new("transactionHash"), TypeData::Simple(TypeRef::named(TypeRef::STRING))),
+        (Name::new("contractAddress"), TypeData::Simple(TypeRef::named(TypeRef::STRING))),
+        (Name::new("entrypoint"), TypeData::Simple(TypeRef::named(TypeRef::STRING))),
+        (Name::new("calldata"), TypeData::Simple(TypeRef::named_list(TypeRef::STRING))),
+        (Name::new("callType"), TypeData::Simple(TypeRef::named(TypeRef::STRING))),
+        (Name::new("callerAddress"), TypeData::Simple(TypeRef::named(TypeRef::STRING))),
+    ]);
     pub static ref TRANSACTION_MAPPING: TypeMapping = IndexMap::from([
         (Name::new("id"), TypeData::Simple(TypeRef::named(TypeRef::ID))),
         (
@@ -98,6 +106,10 @@ lazy_static! {
             Name::new("createdAt"),
             TypeData::Simple(TypeRef::named(GraphqlType::DateTime.to_string())),
         ),
+        (
+            Name::new("blockNumber"),
+            TypeData::Simple(TypeRef::named(TypeRef::STRING)),
+        )
     ]);
     pub static ref PAGE_INFO_TYPE_MAPPING: TypeMapping = TypeMapping::from([
         (Name::new("hasPreviousPage"), TypeData::Simple(TypeRef::named_nn(TypeRef::BOOLEAN))),

crates/torii/graphql/src/mapping.rs

@@ -18,7 +18,7 @@ use crate::object::connection::page_info::PageInfoObject;
 use crate::object::connection::{
     connection_arguments, cursor, parse_connection_arguments, ConnectionArguments,
 };
-use crate::object::erc::erc_token::Erc721Token;
+use crate::object::erc::erc_token::{Erc1155Token, Erc721Token};
 use crate::object::{BasicObject, ResolvableObject};
 use crate::query::order::{CursorDirection, Direction};
 use crate::types::TypeMapping;
@@ -240,72 +240,17 @@ fn token_transfers_connection_output<'a>(
 
     for row in data {
         let row = TransferQueryResultRaw::from_row(row)?;
-        let transaction_hash = get_transaction_hash_from_event_id(&row.id);
         let cursor = cursor::encode(&row.id, &row.id);
 
-        let transfer_node = match row.contract_type.to_lowercase().as_str() {
-            "erc20" => {
-                let token_metadata = ErcTokenType::Erc20(Erc20Token {
-                    contract_address: row.contract_address,
-                    name: row.name,
-                    symbol: row.symbol,
-                    decimals: row.decimals,
-                    amount: row.amount,
-                });
-
-                TokenTransferNode {
-                    from: row.from_address,
-                    to: row.to_address,
-                    executed_at: row.executed_at,
-                    token_metadata,
-                    transaction_hash,
-                }
-            }
-            "erc721" => {
-                // contract_address:token_id
-                let token_id = row.token_id.split(':').collect::<Vec<&str>>();
-                assert!(token_id.len() == 2);
-
-                let metadata_str = row.metadata;
-                let metadata: serde_json::Value =
-                    serde_json::from_str(&metadata_str).expect("metadata is always json");
-                let metadata_name =
-                    metadata.get("name").map(|v| v.to_string().trim_matches('"').to_string());
-                let metadata_description = metadata
-                    .get("description")
-                    .map(|v| v.to_string().trim_matches('"').to_string());
-                let metadata_attributes =
-                    metadata.get("attributes").map(|v| v.to_string().trim_matches('"').to_string());
-
-                let image_path = format!("{}/{}", token_id.join("/"), "image");
-
-                let token_metadata = ErcTokenType::Erc721(Erc721Token {
-                    name: row.name,
-                    metadata: metadata_str.to_owned(),
-                    contract_address: row.contract_address,
-                    symbol: row.symbol,
-                    token_id: token_id[1].to_string(),
-                    metadata_name,
-                    metadata_description,
-                    metadata_attributes,
-                    image_path,
-                });
-
-                TokenTransferNode {
-                    from: row.from_address,
-                    to: row.to_address,
-                    executed_at: row.executed_at,
-                    token_metadata,
-                    transaction_hash,
-                }
+        match token_transfer_mapping_from_row(&row) {
+            Ok(transfer_node) => {
+                edges.push(ConnectionEdge { node: transfer_node, cursor });
             }
-            _ => {
-                warn!("Unknown contract type: {}", row.contract_type);
+            Err(err) => {
+                warn!("Failed to transform row to TokenTransferNode: {}", err);
                 continue;
             }
-        };
-
-        edges.push(ConnectionEdge { node: transfer_node, cursor });
+        }
     }
 
     Ok(FieldValue::owned_any(Connection {
@@ -315,6 +260,128 @@ fn token_transfers_connection_output<'a>(
     }))
 }
 
+/// Transforms a TransferQueryResultRaw into a TokenTransferNode
+pub fn token_transfer_mapping_from_row(
+    row: &TransferQueryResultRaw,
+) -> Result<TokenTransferNode, String> {
+    let transaction_hash = get_transaction_hash_from_event_id(&row.id);
+
+    match row.contract_type.to_lowercase().as_str() {
+        "erc20" => {
+            let token_metadata = ErcTokenType::Erc20(Erc20Token {
+                contract_address: row.contract_address.clone(),
+                name: row.name.clone(),
+                symbol: row.symbol.clone(),
+                decimals: row.decimals,
+                amount: row.amount.clone(),
+            });
+
+            Ok(TokenTransferNode {
+                from: row.from_address.clone(),
+                to: row.to_address.clone(),
+                executed_at: row.executed_at.clone(),
+                token_metadata,
+                transaction_hash,
+            })
+        }
+        "erc721" => {
+            // contract_address:token_id
+            let token_id = row.token_id.split(':').collect::<Vec<&str>>();
+            if token_id.len() != 2 {
+                return Err(format!("Invalid token_id format: {}", row.token_id));
+            }
+
+            let metadata_str = &row.metadata;
+            let metadata: serde_json::Value = match serde_json::from_str(metadata_str) {
+                Ok(value) => value,
+                Err(e) => return Err(format!("Failed to parse metadata as JSON: {}", e)),
+            };
+
+            let metadata_name =
+                metadata.get("name").map(|v| v.to_string().trim_matches('"').to_string());
+            let metadata_description =
+                metadata.get("description").map(|v| v.to_string().trim_matches('"').to_string());
+            let metadata_attributes =
+                metadata.get("attributes").map(|v| v.to_string().trim_matches('"').to_string());
+
+            let image_path = format!("{}/{}", token_id.join("/"), "image");
+
+            let token_metadata = ErcTokenType::Erc721(Erc721Token {
+                name: row.name.clone(),
+                metadata: metadata_str.to_owned(),
+                contract_address: row.contract_address.clone(),
+                symbol: row.symbol.clone(),
+                token_id: token_id[1].to_string(),
+                metadata_name,
+                metadata_description,
+                metadata_attributes,
+                image_path,
+            });
+
+            Ok(TokenTransferNode {
+                from: row.from_address.clone(),
+                to: row.to_address.clone(),
+                executed_at: row.executed_at.clone(),
+                token_metadata,
+                transaction_hash,
+            })
+        }
+        "erc1155" => {
+            // contract_address:token_id
+            let token_id = row.token_id.split(':').collect::<Vec<&str>>();
+            if token_id.len() != 2 {
+                return Err(format!("Invalid token_id format: {}", row.token_id));
+            }
+
+            let metadata_str = &row.metadata;
+            let (metadata_name, metadata_description, metadata_attributes, image_path) =
+                if metadata_str.is_empty() {
+                    (None, None, None, String::new())
+                } else {
+                    let metadata: serde_json::Value = match serde_json::from_str(metadata_str) {
+                        Ok(value) => value,
+                        Err(e) => return Err(format!("Failed to parse metadata as JSON: {}", e)),
+                    };
+
+                    let metadata_name =
+                        metadata.get("name").map(|v| v.to_string().trim_matches('"').to_string());
+                    let metadata_description = metadata
+                        .get("description")
+                        .map(|v| v.to_string().trim_matches('"').to_string());
+                    let metadata_attributes = metadata
+                        .get("attributes")
+                        .map(|v| v.to_string().trim_matches('"').to_string());
+
+                    let image_path = format!("{}/{}", token_id.join("/"), "image");
+
+                    (metadata_name, metadata_description, metadata_attributes, image_path)
+                };
+
+            let token_metadata = ErcTokenType::Erc1155(Erc1155Token {
+                name: row.name.clone(),
+                metadata: metadata_str.to_owned(),
+                contract_address: row.contract_address.clone(),
+                symbol: row.symbol.clone(),
+                token_id: token_id[1].to_string(),
+                amount: row.amount.clone(),
+                metadata_name,
+                metadata_description,
+                metadata_attributes,
+                image_path,
+            });
+
+            Ok(TokenTransferNode {
+                from: row.from_address.clone(),
+                to: row.to_address.clone(),
+                executed_at: row.executed_at.clone(),
+                token_metadata,
+                transaction_hash,
+            })
+        }
+        _ => Err(format!("Unknown contract type: {}", row.contract_type)),
+    }
+}
+
 // TODO: This would be required when subscriptions are needed
 // impl ErcTransferObject {
 //     pub fn value_mapping(entity: ErcBalance) -> ValueMapping {
@@ -325,7 +392,7 @@ fn token_transfers_connection_output<'a>(
 
 #[derive(FromRow, Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
-struct TransferQueryResultRaw {
+pub struct TransferQueryResultRaw {
     pub id: String,
     pub contract_address: String,
     pub from_address: String,

crates/torii/graphql/src/object/erc/token_balance.rs

@@ -28,7 +28,9 @@ use self::connection::{
 };
 use self::inputs::keys_input::parse_keys_argument;
 use self::inputs::order_input::parse_order_argument;
-use crate::query::data::{count_rows, fetch_multiple_rows, fetch_single_row};
+use crate::query::data::{
+    count_rows, fetch_multiple_rows, fetch_single_row, fetch_single_row_with_joins, JoinConfig,
+};
 use crate::query::value_mapping_from_row;
 use crate::types::{TypeMapping, ValueMapping};
 use crate::utils::extract;
@@ -270,6 +272,51 @@ pub fn resolve_one(
     .argument(argument)
 }
 
+// Resolves single object queries with joins, returns current object of type type_name with related
+// data
+pub fn resolve_one_with_joins(
+    table_name: &str,
+    id_column: &str,
+    field_name: &str,
+    type_name: &str,
+    type_mapping: &TypeMapping,
+    joins: Vec<JoinConfig>,
+    select_columns: Option<Vec<String>>,
+) -> Field {
+    let type_mapping = type_mapping.clone();
+    let table_name = table_name.to_owned();
+    let id_column = id_column.to_owned();
+    let joins = joins.to_owned();
+    let select_columns = select_columns.to_owned();
+    let argument = InputValue::new(id_column.to_case(Case::Camel), TypeRef::named_nn(TypeRef::ID));
+
+    Field::new(field_name, TypeRef::named_nn(type_name), move |ctx| {
+        let type_mapping = type_mapping.clone();
+        let table_name = table_name.to_owned();
+        let id_column = id_column.to_owned();
+        let joins = joins.to_owned();
+        let select_columns = select_columns.to_owned();
+
+        FieldFuture::new(async move {
+            let mut conn = ctx.data::<Pool<Sqlite>>()?.acquire().await?;
+            let id: String =
+                extract::<String>(ctx.args.as_index_map(), &id_column.to_case(Case::Camel))?;
+            let data = fetch_single_row_with_joins(
+                &mut conn,
+                &table_name,
+                &id_column,
+                &id,
+                joins,
+                select_columns,
+            )
+            .await?;
+            let model = value_mapping_from_row(&data, &type_mapping, false, true)?;
+            Ok(Some(Value::Object(model)))
+        })
+    })
+    .argument(argument)
+}
+
 // Resolves plural object queries, returns type of {type_name}Connection (eg "PlayerConnection")
 pub fn resolve_many(
     table_name: &str,