feat(torii): model upgrades

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

@@ -117,6 +117,41 @@ where
         })
     }
 
+    pub async fn new_with_selector(
+        selector: Felt,
+        world: &'a WorldContractReader<P>,
+    ) -> Result<ModelRPCReader<'a, P>, ModelError> {
+        // Events are also considered like models from a off-chain perspective. They both have
+        // introspection and convey type information.
+        let (contract_address, class_hash) =
+            match world.resource(&selector).block_id(world.block_id).call().await? {
+                abigen::world::Resource::Model((address, hash)) => (address, hash),
+                abigen::world::Resource::Event((address, hash)) => (address, hash),
+                _ => return Err(ModelError::ModelNotFound),
+            };
+
+        // World Cairo contract won't raise an error in case of unknown/unregistered
+        // model so raise an error here in case of zero address.
+        if contract_address == ContractAddress(Felt::ZERO) {
+            return Err(ModelError::ModelNotFound);
+        }
+
+        let model_reader = ModelContractReader::new(contract_address.into(), world.provider());
+        let tag = model_reader.dojo_name().call().await?;
+        // Safe to unwrap, since it's coming from the chain.
+        let (namespace, name) = naming::split_tag(&tag.to_string().unwrap()).unwrap();
+
+        Ok(Self {
+            namespace: namespace.into(),
+            name: name.into(),
+            world_reader: world,
+            class_hash,
+            contract_address: contract_address.into(),
+            selector,
+            model_reader,
+        })
+    }
+
     pub async fn entity_storage(&self, keys: &[Felt]) -> Result<Vec<Felt>, ModelError> {
         // As the dojo::model::Layout type has been pasted
         // in both `model` and `world` ABI by abigen, the compiler sees both types

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

@@ -1,6 +1,7 @@
 use std::result::Result;
 
 use starknet::providers::Provider;
+use starknet_crypto::Felt;
 
 pub use super::abigen::world::{
     ContractRegistered, ContractUpgraded, Event as WorldEvent, ModelRegistered, WorldContract,
@@ -33,4 +34,11 @@ where
     ) -> Result<ModelRPCReader<'_, P>, ModelError> {
         ModelRPCReader::new(namespace, name, self).await
     }
+
+    pub async fn model_reader_with_selector(
+        &self,
+        selector: Felt,
+    ) -> Result<ModelRPCReader<'_, P>, ModelError> {
+        ModelRPCReader::new_with_selector(selector, self).await
+    }
 }

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_model;
+pub mod upgrade_event;
 
 const MODEL_INDEX: usize = 0;
 const ENTITY_ID_INDEX: usize = 1;

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

@@ -21,7 +21,7 @@ where
     P: Provider + Send + Sync + std::fmt::Debug,
 {
     fn event_key(&self) -> String {
-        "EventRegistered".to_string()
+        "EventUpgraded".to_string()
     }
 
     // We might not need this anymore, since we don't have fallback and all world events must
@@ -71,7 +71,7 @@ where
             target: LOG_TARGET,
             namespace = %namespace,
             name = %name,
-            "Registered event."
+            "Upgraded event."
         );
 
         debug!(
@@ -83,7 +83,7 @@ where
             contract_address = ?event.address,
             packed_size = %packed_size,
             unpacked_size = %unpacked_size,
-            "Registered model content."
+            "Upgraded event content."
         );
 
         db.register_model(
@@ -95,6 +95,7 @@ where
             packed_size,
             unpacked_size,
             block_timestamp,
+            true,
         )
         .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,102 @@
+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::register_event";
+
+#[derive(Default, Debug)]
+pub struct RegisterEventProcessor;
+
+#[async_trait]
+impl<P> EventProcessor<P> for RegisterEventProcessor
+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.",
+                <RegisterEventProcessor 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 = world.model_reader_with_selector(event.selector).await?;
+        let namespace = model.namespace();
+        let name = model.name();
+        let schema = model.schema().await?;
+        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,
+            "Registered event."
+        );
+
+        debug!(
+            target: LOG_TARGET,
+            name,
+            schema = ?schema,
+            layout = ?layout,
+            class_hash = ?event.class_hash,
+            contract_address = ?event.address,
+            packed_size = %packed_size,
+            unpacked_size = %unpacked_size,
+            "Registered model content."
+        );
+
+        db.register_model(
+            &namespace,
+            schema,
+            layout,
+            event.class_hash.into(),
+            event.address.into(),
+            packed_size,
+            unpacked_size,
+            block_timestamp,
+            false,
+        )
+        .await?;
+
+        Ok(())
+    }
+}

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

@@ -0,0 +1,98 @@
+use anyhow::{Error, Ok, Result};
+use async_trait::async_trait;
+use dojo_world::contracts::{abigen::world::Event as WorldEvent, 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::register_model";
+
+#[derive(Default, Debug)]
+pub struct RegisterModelProcessor;
+
+#[async_trait]
+impl<P> EventProcessor<P> for RegisterModelProcessor
+where
+    P: Provider + Send + Sync + std::fmt::Debug,
+{
+    fn event_key(&self) -> String {
+        "ModelUpgraded".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.",
+                <RegisterModelProcessor as EventProcessor<P>>::event_key(self)
+            )
+        }) {
+            WorldEvent::ModelUpgraded(e) => e,
+            _ => {
+                unreachable!()
+            }
+        };
+
+        let model = world.model_reader_with_selector(event.selector).await?;
+        let namespace = model.namespace();
+        let name = model.name();
+        let schema = model.schema().await?;
+        let layout = model.layout().await?;
+
+        let unpacked_size: u32 = model.unpacked_size().await?;
+        let packed_size: u32 = model.packed_size().await?;
+
+        info!(
+            target: LOG_TARGET,
+            namespace = %namespace,
+            name = %name,
+            "Upgraded model."
+        );
+
+        debug!(
+            target: LOG_TARGET,
+            name = %name,
+            schema = ?schema,
+            layout = ?layout,
+            class_hash = ?event.class_hash,
+            contract_address = ?event.address,
+            packed_size = %packed_size,
+            unpacked_size = %unpacked_size,
+            "Upgraded model content."
+        );
+
+        db.register_model(
+            &namespace,
+            schema,
+            layout,
+            event.class_hash.into(),
+            event.address.into(),
+            packed_size,
+            unpacked_size,
+            block_timestamp,
+            true,
+        )
+        .await?;
+
+        Ok(())
+    }
+}