merge main

crates/torii/cli/src/args.rs

@@ -218,12 +218,9 @@ mod test {
             "http://0.0.0.0:6060",
             "--db-dir",
             "/tmp/torii-test2",
-            "--events.raw",
-            "false",
             "--events.historical",
             "a-A",
             "--indexing.transactions",
-            "true",
             "--config",
             path_str.as_str(),
         ];

crates/torii/cli/src/options.rs

@@ -2,7 +2,6 @@ use std::net::{IpAddr, Ipv4Addr};
 use std::str::FromStr;
 
 use anyhow::Context;
-use clap::ArgAction;
 use serde::ser::SerializeSeq;
 use serde::{Deserialize, Serialize};
 use starknet::core::types::Felt;
@@ -102,7 +101,11 @@ pub struct IndexingOptions {
     pub blocks_chunk_size: u64,
 
     /// Enable indexing pending blocks
-    #[arg(long = "indexing.pending", action = ArgAction::Set, default_value_t = true, help = "Whether or not to index pending blocks.")]
+    #[arg(
+        long = "indexing.pending",
+        default_value_t = true,
+        help = "Whether or not to index pending blocks."
+    )]
     #[serde(default)]
     pub pending: bool,
 
@@ -127,7 +130,6 @@ pub struct IndexingOptions {
     /// Whether or not to index world transactions
     #[arg(
         long = "indexing.transactions",
-        action = ArgAction::Set,
         default_value_t = false,
         help = "Whether or not to index world transactions and keep them in the database."
     )]
@@ -214,7 +216,11 @@ impl IndexingOptions {
 #[command(next_help_heading = "Events indexing options")]
 pub struct EventsOptions {
     /// Whether or not to index raw events
-    #[arg(long = "events.raw", action = ArgAction::Set, default_value_t = false, help = "Whether or not to index raw events.")]
+    #[arg(
+        long = "events.raw",
+        default_value_t = false,
+        help = "Whether or not to index raw events."
+    )]
     #[serde(default)]
     pub raw: bool,
 

crates/torii/core/src/sql/mod.rs

@@ -543,6 +543,14 @@ impl Sql {
 
         let (transaction_hash, sender_address, calldata, max_fee, signature, nonce) =
             match transaction {
+                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)),
+                    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),

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

@@ -103,10 +103,10 @@ async fn fetch_token_balances(
          JOIN tokens t ON b.token_id = t.id
          JOIN contracts c ON t.contract_address = c.contract_address"
     );
+
+    // Only select balances for the given account address and non-zero balances.
     let mut conditions = vec![
         "(b.account_address = ?)".to_string(),
-        "(t.metadata IS NULL OR length(t.metadata) > 0)".to_string(),
-        // Filter out zero balance
         "b.balance != '0x0000000000000000000000000000000000000000000000000000000000000000'"
             .to_string(),
     ];
@@ -241,17 +241,36 @@ fn token_balances_connection_output<'a>(
                 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 (
+                    metadata_str,
+                    metadata_name,
+                    metadata_description,
+                    metadata_attributes,
+                    image_path,
+                ) = if metadata_str.is_empty() {
+                    (String::new(), None, None, None, String::new())
+                } else {
+                    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");
+
+                    (
+                        metadata_str,
+                        metadata_name,
+                        metadata_description,
+                        metadata_attributes,
+                        image_path,
+                    )
+                };
 
                 let token_metadata = Erc721Token {
                     name: row.name,