feat(torii): model upgrades

crates/dojo/types/src/schema.rs

@@ -224,6 +224,87 @@
         }
         Ok(())
     }
+
+    /// Returns a new Ty containing only the differences between self and other
+    pub fn diff(&self, other: &Ty) -> Option<Ty> {
+        match (self, other) {
+            (Ty::Struct(s1), Ty::Struct(s2)) => {
+                // Find members that exist in s1 but not in s2, or are different
+                let diff_children: Vec<Member> = s1
+                    .children
+                    .iter()
+                    .filter(|m1| {
+                        s2.children
+                            .iter()
+                            .find(|m2| m2.name == m1.name)
+                            .map_or(true, |m2| *m1 != m2)
+                    })
+                    .cloned()
+                    .collect();
+
+                if diff_children.is_empty() {
+                    None
+                } else {
+                    Some(Ty::Struct(Struct { name: s1.name.clone(), children: diff_children }))
+                }
+            }
+            (Ty::Enum(e1), Ty::Enum(e2)) => {
+                // Find options that exist in e1 but not in e2, or are different
+                let diff_options: Vec<EnumOption> = e1
+                    .options
+                    .iter()
+                    .filter(|o1| {
+                        e2.options.iter().find(|o2| o2.name == o1.name).map_or(true, |o2| *o1 != o2)
+                    })
+                    .cloned()
+                    .collect();
+
+                if diff_options.is_empty() {
+                    None
+                } else {
+                    Some(Ty::Enum(Enum {
+                        name: e1.name.clone(),
+                        option: e1.option,
+                        options: diff_options,
+                    }))
+                }
+            }
+            (Ty::Array(a1), Ty::Array(a2)) => {
+                if a1 == a2 {
+                    None
+                } else {
+                    Some(Ty::Array(a1.clone()))
+                }
+            }
+            (Ty::Tuple(t1), Ty::Tuple(t2)) => {
+                if t1 == t2 {
+                    None
+                } else {
+                    Some(Ty::Tuple(t1.clone()))
+                }
+            }
+            (Ty::ByteArray(b1), Ty::ByteArray(b2)) => {
+                if b1 == b2 {
+                    None
+                } else {
+                    Some(Ty::ByteArray(b1.clone()))
+                }
+            }
+            (Ty::Primitive(p1), Ty::Primitive(p2)) => {
+                if p1 == p2 {
+                    None
+                } else {
+                    Some(Ty::Primitive(*p1))
+                }
+            }
+            // Different types entirely - we cannot diff them
+            _ => panic!(
+                "Type mismatch between self {:?} and other {:?}",
+                self.name(),
+                other.name()
+            ),
+        }
+    }
 }
 
 #[derive(Debug)]
@@ -597,4 +678,77 @@
             assert_eq!(format_member(&member), expected);
         }
     }
+
+    #[test]
+    fn test_ty_diff() {
+        // Test struct diff
+        let struct1 = Ty::Struct(Struct {
+            name: "TestStruct".to_string(),
+            children: vec![
+                Member {
+                    name: "field1".to_string(),
+                    ty: Ty::Primitive(Primitive::U32(None)),
+                    key: false,
+                },
+                Member {
+                    name: "field2".to_string(),
+                    ty: Ty::Primitive(Primitive::U32(None)),
+                    key: false,
+                },
+                Member {
+                    name: "field3".to_string(),
+                    ty: Ty::Primitive(Primitive::U32(None)),
+                    key: false,
+                },
+            ],
+        });
+
+        let struct2 = Ty::Struct(Struct {
+            name: "TestStruct".to_string(),
+            children: vec![Member {
+                name: "field1".to_string(),
+                ty: Ty::Primitive(Primitive::U32(None)),
+                key: false,
+            }],
+        });
+
+        // Should show only field2 and field3 as differences
+        let diff = struct1.diff(&struct2).unwrap();
+        if let Ty::Struct(s) = diff {
+            assert_eq!(s.children.len(), 2);
+            assert_eq!(s.children[0].name, "field2");
+            assert_eq!(s.children[1].name, "field3");
+        } else {
+            panic!("Expected Struct diff");
+        }
+
+        // Test enum diff
+        let enum1 = Ty::Enum(Enum {
+            name: "TestEnum".to_string(),
+            option: None,
+            options: vec![
+                EnumOption { name: "Option1".to_string(), ty: Ty::Tuple(vec![]) },
+                EnumOption { name: "Option2".to_string(), ty: Ty::Tuple(vec![]) },
+            ],
+        });
+
+        let enum2 = Ty::Enum(Enum {
+            name: "TestEnum".to_string(),
+            option: None,
+            options: vec![EnumOption { name: "Option1".to_string(), ty: Ty::Tuple(vec![]) }],
+        });
+
+        // Should show only Option2 as difference
+        let diff = enum1.diff(&enum2).unwrap();
+        if let Ty::Enum(e) = diff {
+            assert_eq!(e.options.len(), 1);
+            assert_eq!(e.options[0].name, "Option2");
+        } else {
+            panic!("Expected Enum diff");
+        }
+
+        // Test no differences
+        let same_struct = struct2.diff(&struct2);
+        assert!(same_struct.is_none());
+    }
 }

crates/dojo/world/src/contracts/model.rs

@@ -176,7 +176,7 @@ where
         parse_schema(&abigen::model::Ty::Struct(res)).map_err(ModelError::Parse)
     }
 
-    // For non fixed layouts, packed and unpacked sizes are None.
+    // For non fixed layouts,   packed and unpacked sizes are None.
     // Therefore we return 0 in this case.
     async fn packed_size(&self) -> Result<u32, ModelError> {
         Ok(self.model_reader.packed_size().call().await?.unwrap_or(0))

crates/torii/core/src/engine.rs

@@ -37,6 +37,8 @@ use crate::processors::store_del_record::StoreDelRecordProcessor;
 use crate::processors::store_set_record::StoreSetRecordProcessor;
 use crate::processors::store_update_member::StoreUpdateMemberProcessor;
 use crate::processors::store_update_record::StoreUpdateRecordProcessor;
+use crate::processors::upgrade_event::UpgradeEventProcessor;
+use crate::processors::upgrade_model::UpgradeModelProcessor;
 use crate::processors::{BlockProcessor, EventProcessor, TransactionProcessor};
 use crate::sql::{Cursors, Sql};
 use crate::types::ContractType;
@@ -74,6 +76,8 @@ impl<P: Provider + Send + Sync + std::fmt::Debug + 'static> Processors<P> {
                 vec![
                     Box::new(RegisterModelProcessor) as Box<dyn EventProcessor<P>>,
                     Box::new(RegisterEventProcessor) as Box<dyn EventProcessor<P>>,
+                    Box::new(UpgradeModelProcessor) as Box<dyn EventProcessor<P>>,
+                    Box::new(UpgradeEventProcessor) as Box<dyn EventProcessor<P>>,
                     Box::new(StoreSetRecordProcessor),
                     Box::new(StoreDelRecordProcessor),
                     Box::new(StoreUpdateRecordProcessor),

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

@@ -20,6 +20,8 @@ pub mod store_set_record;
 pub mod store_transaction;
 pub mod store_update_member;
 pub mod store_update_record;
+pub mod upgrade_event;
+pub mod upgrade_model;
 
 const MODEL_INDEX: usize = 0;
 const ENTITY_ID_INDEX: usize = 1;

crates/torii/core/src/processors/register_event.rs

@@ -83,7 +83,7 @@ where
             contract_address = ?event.address,
             packed_size = %packed_size,
             unpacked_size = %unpacked_size,
-            "Registered model content."
+            "Registered event content."
         );
 
         db.register_model(
@@ -95,6 +95,7 @@ where
             packed_size,
             unpacked_size,
             block_timestamp,
+            false,
         )
         .await?;
 

crates/torii/core/src/processors/register_model.rs

@@ -92,6 +92,7 @@ where
             packed_size,
             unpacked_size,
             block_timestamp,
+            false,
         )
         .await?;
 

crates/torii/core/src/processors/upgrade_event.rs

@@ -0,0 +1,113 @@
+use anyhow::{Error, Ok, Result};
+use async_trait::async_trait;
+use dojo_world::contracts::abigen::world::Event as WorldEvent;
+use dojo_world::contracts::model::ModelReader;
+use dojo_world::contracts::world::WorldContractReader;
+use starknet::core::types::Event;
+use starknet::providers::Provider;
+use tracing::{debug, info};
+
+use super::EventProcessor;
+use crate::sql::Sql;
+
+pub(crate) const LOG_TARGET: &str = "torii_core::processors::upgrade_event";
+
+#[derive(Default, Debug)]
+pub struct UpgradeEventProcessor;
+
+#[async_trait]
+impl<P> EventProcessor<P> for UpgradeEventProcessor
+where
+    P: Provider + Send + Sync + std::fmt::Debug,
+{
+    fn event_key(&self) -> String {
+        "EventUpgraded".to_string()
+    }
+
+    // We might not need this anymore, since we don't have fallback and all world events must
+    // be handled.
+    fn validate(&self, _event: &Event) -> bool {
+        true
+    }
+
+    async fn process(
+        &self,
+        world: &WorldContractReader<P>,
+        db: &mut Sql,
+        _block_number: u64,
+        block_timestamp: u64,
+        _event_id: &str,
+        event: &Event,
+    ) -> Result<(), Error> {
+        // Torii version is coupled to the world version, so we can expect the event to be well
+        // formed.
+        let event = match WorldEvent::try_from(event).unwrap_or_else(|_| {
+            panic!(
+                "Expected {} event to be well formed.",
+                <UpgradeEventProcessor as EventProcessor<P>>::event_key(self)
+            )
+        }) {
+            WorldEvent::EventUpgraded(e) => e,
+            _ => {
+                unreachable!()
+            }
+        };
+
+        // Called model here by language, but it's an event. Torii rework will make clear
+        // distinction.
+        let model = db.model(event.selector).await?;
+        let name = model.name;
+        let namespace = model.namespace;
+        let prev_schema = model.schema;
+
+        let model = world.model_reader(&namespace, &name).await?;
+        let new_schema = model.schema().await?;
+        let schema_diff = new_schema.diff(&prev_schema);
+        // No changes to the schema. This can happen if torii is re-run with a fresh database.
+        // As the register model fetches the latest schema from the chain.
+        if schema_diff.is_none() {
+            return Ok(());
+        }
+
+        let schema_diff = schema_diff.unwrap();
+        let layout = model.layout().await?;
+
+        // Events are never stored onchain, hence no packing or unpacking.
+        let unpacked_size: u32 = 0;
+        let packed_size: u32 = 0;
+
+        info!(
+            target: LOG_TARGET,
+            namespace = %namespace,
+            name = %name,
+            "Upgraded event."
+        );
+
+        debug!(
+            target: LOG_TARGET,
+            name,
+            diff = ?schema_diff,
+            layout = ?layout,
+            class_hash = ?event.class_hash,
+            contract_address = ?event.address,
+            packed_size = %packed_size,
+            unpacked_size = %unpacked_size,
+            "Upgraded event content."
+        );
+
+        db.register_model(
+            &namespace,
+            schema_diff,
+            layout,
+            event.class_hash.into(),
+            event.address.into(),
+            packed_size,
+            unpacked_size,
+            block_timestamp,
+            true,
+        )
+        .await?;
+
+        Ok(())
+    }
+}