wip

bin/sozo/src/commands/migrate.rs

@@ -75,6 +75,8 @@ impl MigrateArgs {
             let MigrationResult { manifest, has_changes } =
                 migration.migrate(&mut spinner).await.context("Migration failed.")?;
 
+            migration.upload_metadata(&mut spinner).await.context("Metadata upload failed.")?;
+
             spinner.update_text("Writing manifest...");
             ws.write_manifest_profile(manifest).context("🪦 Failed to write manifest.")?;
 

crates/dojo/core-cairo-test/src/tests/world/metadata.cairo

@@ -9,7 +9,7 @@ fn test_set_metadata_world() {
     let world = world.dispatcher;
 
     let metadata = ResourceMetadata {
-        resource_id: 0, metadata_uri: format!("ipfs:world_with_a_long_uri_that")
+        resource_id: 0, metadata_uri: format!("ipfs:world_with_a_long_uri_that"), metadata_hash: 42
     };
 
     world.set_metadata(metadata.clone());
@@ -30,7 +30,7 @@ fn test_set_metadata_resource_owner() {
     starknet::testing::set_contract_address(bob);
 
     let metadata = ResourceMetadata {
-        resource_id: model_selector, metadata_uri: format!("ipfs:bob")
+        resource_id: model_selector, metadata_uri: format!("ipfs:bob"), metadata_hash: 42
     };
 
     drop_all_events(world.contract_address);
@@ -46,6 +46,7 @@ fn test_set_metadata_resource_owner() {
     if let world::Event::MetadataUpdate(event) = event.unwrap() {
         assert(event.resource == metadata.resource_id, 'bad resource');
         assert(event.uri == metadata.metadata_uri, 'bad uri');
+        assert(event.hash == metadata.metadata_hash, 'bad hash');
     } else {
         core::panic_with_felt252('no EventUpgraded event');
     }
@@ -70,7 +71,7 @@ fn test_set_metadata_not_possible_for_resource_writer() {
     starknet::testing::set_contract_address(bob);
 
     let metadata = ResourceMetadata {
-        resource_id: model_selector, metadata_uri: format!("ipfs:bob")
+        resource_id: model_selector, metadata_uri: format!("ipfs:bob"), metadata_hash: 42
     };
 
     world.set_metadata(metadata.clone());
@@ -85,7 +86,7 @@ fn test_set_metadata_not_possible_for_random_account() {
     let world = world.dispatcher;
 
     let metadata = ResourceMetadata { // World metadata.
-        resource_id: 0, metadata_uri: format!("ipfs:bob"),
+        resource_id: 0, metadata_uri: format!("ipfs:bob"), metadata_hash: 42
     };
 
     let bob = starknet::contract_address_const::<0xb0b>();
@@ -112,7 +113,7 @@ fn test_set_metadata_through_malicious_contract() {
     starknet::testing::set_contract_address(malicious_contract);
 
     let metadata = ResourceMetadata {
-        resource_id: model_selector, metadata_uri: format!("ipfs:bob")
+        resource_id: model_selector, metadata_uri: format!("ipfs:bob"), metadata_hash: 42
     };
 
     world.set_metadata(metadata.clone());

crates/dojo/core/src/model/metadata.cairo

@@ -9,6 +9,7 @@ pub struct ResourceMetadata {
     #[key]
     pub resource_id: felt252,
     pub metadata_uri: ByteArray,
+    pub metadata_hash: felt252
 }
 
 pub fn default_address() -> starknet::ContractAddress {

crates/dojo/core/src/world/world_contract.cairo

@@ -111,7 +111,8 @@ pub mod world {
     pub struct MetadataUpdate {
         #[key]
         pub resource: felt252,
-        pub uri: ByteArray
+        pub uri: ByteArray,
+        pub hash: felt252
     }
 
     #[derive(Drop, starknet::Event)]
@@ -356,7 +357,11 @@ pub mod world {
 
             self
                 .emit(
-                    MetadataUpdate { resource: metadata.resource_id, uri: metadata.metadata_uri }
+                    MetadataUpdate {
+                        resource: metadata.resource_id,
+                        uri: metadata.metadata_uri,
+                        hash: metadata.metadata_hash
+                    }
                 );
         }
 

crates/dojo/world/src/config/metadata_config.rs

@@ -1,11 +1,13 @@
 //! Metadata configuration for the world.
 
 use std::collections::HashMap;
+use std::hash::{Hash, Hasher};
 
 use serde::{Deserialize, Serialize};
+use serde_json::json;
 use url::Url;
 
-use crate::config::WorldConfig;
+use crate::config::{ResourceConfig, WorldConfig};
 use crate::uri::Uri;
 
 /// World metadata that describes the world.
@@ -33,3 +35,61 @@ impl From<WorldConfig> for WorldMetadata {
         }
     }
 }
+
+impl Hash for WorldMetadata {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.name.hash(state);
+        self.seed.hash(state);
+        self.description.hash(state);
+        self.cover_uri.hash(state);
+        self.icon_uri.hash(state);
+        self.website.hash(state);
+
+        json!(self.socials).to_string().hash(state);
+
+        // include icon and cover data into the hash to
+        // detect data changes even if the filename is the same.
+        if let Some(Uri::File(icon)) = &self.icon_uri {
+            let icon_data = std::fs::read(icon).expect("read icon failed");
+            icon_data.hash(state);
+        };
+
+        if let Some(Uri::File(cover)) = &self.cover_uri {
+            let cover_data = std::fs::read(cover).expect("read cover failed");
+            cover_data.hash(state);
+        };
+    }
+}
+
+/// resource metadata (for contracts, models, ...)
+#[derive(Default, Serialize, Deserialize, Debug, Clone)]
+pub struct ResourceMetadata {
+    pub name: String,
+    pub description: Option<String>,
+    pub icon_uri: Option<Uri>,
+}
+
+impl From<ResourceConfig> for ResourceMetadata {
+    fn from(config: ResourceConfig) -> Self {
+        ResourceMetadata {
+            name: config.name,
+            description: config.description,
+            icon_uri: config.icon_uri,
+        }
+    }
+}
+
+impl Hash for ResourceMetadata {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.name.hash(state);
+        self.description.hash(state);
+        self.icon_uri.hash(state);
+
+        // include icon and cover data into the hash to
+        // detect data changes even if the filename is the same.
+        if let Some(Uri::File(icon)) = &self.icon_uri {
+            let icon_data = std::fs::read(icon).expect("read icon failed");
+            icon_data.hash(state);
+        };
+    }
+}

crates/dojo/world/src/config/mod.rs

@@ -4,10 +4,12 @@ pub mod metadata_config;
 pub mod migration_config;
 pub mod namespace_config;
 pub mod profile_config;
+pub mod resource_config;
 pub mod world_config;
 
 pub use environment::Environment;
 pub use metadata_config::WorldMetadata;
 pub use namespace_config::NamespaceConfig;
 pub use profile_config::ProfileConfig;
+pub use resource_config::ResourceConfig;
 pub use world_config::WorldConfig;

crates/dojo/world/src/config/profile_config.rs

@@ -9,6 +9,7 @@ use toml;
 use super::environment::Environment;
 use super::migration_config::MigrationConfig;
 use super::namespace_config::NamespaceConfig;
+use super::resource_config::ResourceConfig;
 use super::world_config::WorldConfig;
 
 /// Profile configuration that is used to configure the world and its environment.
@@ -17,6 +18,9 @@ use super::world_config::WorldConfig;
 #[derive(Debug, Clone, Default, Deserialize)]
 pub struct ProfileConfig {
     pub world: WorldConfig,
+    pub models: Option<Vec<ResourceConfig>>,
+    pub contracts: Option<Vec<ResourceConfig>>,
+    pub events: Option<Vec<ResourceConfig>>,
     pub namespace: NamespaceConfig,
     pub env: Option<Environment>,
     pub migration: Option<MigrationConfig>,
@@ -134,6 +138,24 @@ mod tests {
         website = "https://example.com"
         socials = { "twitter" = "test", "discord" = "test" }
 
+        [[models]]
+        tag = "ns1-m1"
+        name = "m1"
+        description = "This is the m1 model"
+        icon_uri = "ipfs://dojo/m1.png"
+
+        [[contracts]]
+        tag = "ns1-c1"
+        name = "c1"
+        description = "This is the c1 contract"
+        icon_uri = "ipfs://dojo/c1.png"
+
+        [[events]]
+        tag = "ns1-e1"
+        name = "e1"
+        description = "This is the e1 event"
+        icon_uri = "ipfs://dojo/e1.png"
+
         [namespace]
         default = "test"
         mappings = { "test" = ["test2"] }
@@ -190,6 +212,30 @@ mod tests {
             ]))
         );
 
+        assert!(config.models.is_some());
+        let models = config.models.unwrap();
+        assert_eq!(models.len(), 1);
+        assert_eq!(models[0].tag, "ns1-m1");
+        assert_eq!(models[0].name, "m1");
+        assert_eq!(models[0].description, Some("This is the m1 model".to_string()));
+        assert_eq!(models[0].icon_uri, Some(Uri::from_string("ipfs://dojo/m1.png").unwrap()));
+
+        assert!(config.contracts.is_some());
+        let contracts = config.contracts.unwrap();
+        assert_eq!(contracts.len(), 1);
+        assert_eq!(contracts[0].tag, "ns1-c1");
+        assert_eq!(contracts[0].name, "c1");
+        assert_eq!(contracts[0].description, Some("This is the c1 contract".to_string()));
+        assert_eq!(contracts[0].icon_uri, Some(Uri::from_string("ipfs://dojo/c1.png").unwrap()));
+
+        assert!(config.events.is_some());
+        let events = config.events.unwrap();
+        assert_eq!(events.len(), 1);
+        assert_eq!(events[0].tag, "ns1-e1");
+        assert_eq!(events[0].name, "e1");
+        assert_eq!(events[0].description, Some("This is the e1 event".to_string()));
+        assert_eq!(events[0].icon_uri, Some(Uri::from_string("ipfs://dojo/e1.png").unwrap()));
+
         assert_eq!(config.namespace.default, "test".to_string());
         assert_eq!(
             config.namespace.mappings,

crates/dojo/world/src/config/resource_config.rs

@@ -0,0 +1,11 @@
+use serde::Deserialize;
+
+use crate::uri::Uri;
+
+#[derive(Debug, Clone, Default, Deserialize)]
+pub struct ResourceConfig {
+    pub tag: String,
+    pub name: String,
+    pub description: Option<String>,
+    pub icon_uri: Option<Uri>,
+}

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

@@ -393,6 +393,7 @@ impl cainome::cairo_serde::CairoSerde for FieldLayout {
 pub struct MetadataUpdate {
     pub resource: starknet::core::types::Felt,
     pub uri: cainome::cairo_serde::ByteArray,
+    pub hash: starknet::core::types::Felt,
 }
 impl cainome::cairo_serde::CairoSerde for MetadataUpdate {
     type RustType = Self;
@@ -402,12 +403,14 @@ impl cainome::cairo_serde::CairoSerde for MetadataUpdate {
         let mut __size = 0;
         __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.resource);
         __size += cainome::cairo_serde::ByteArray::cairo_serialized_size(&__rust.uri);
+        __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.hash);
         __size
     }
     fn cairo_serialize(__rust: &Self::RustType) -> Vec<starknet::core::types::Felt> {
         let mut __out: Vec<starknet::core::types::Felt> = vec![];
         __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.resource));
         __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize(&__rust.uri));
+        __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.hash));
         __out
     }
     fn cairo_deserialize(
@@ -419,7 +422,9 @@ impl cainome::cairo_serde::CairoSerde for MetadataUpdate {
         __offset += starknet::core::types::Felt::cairo_serialized_size(&resource);
         let uri = cainome::cairo_serde::ByteArray::cairo_deserialize(__felts, __offset)?;
         __offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&uri);
-        Ok(MetadataUpdate { resource, uri })
+        let hash = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?;
+        __offset += starknet::core::types::Felt::cairo_serialized_size(&hash);
+        Ok(MetadataUpdate { resource, uri, hash })
     }
 }
 impl MetadataUpdate {
@@ -625,6 +630,7 @@ impl OwnerUpdated {
 pub struct ResourceMetadata {
     pub resource_id: starknet::core::types::Felt,
     pub metadata_uri: cainome::cairo_serde::ByteArray,
+    pub metadata_hash: starknet::core::types::Felt,
 }
 impl cainome::cairo_serde::CairoSerde for ResourceMetadata {
     type RustType = Self;
@@ -634,12 +640,14 @@ impl cainome::cairo_serde::CairoSerde for ResourceMetadata {
         let mut __size = 0;
         __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.resource_id);
         __size += cainome::cairo_serde::ByteArray::cairo_serialized_size(&__rust.metadata_uri);
+        __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.metadata_hash);
         __size
     }
     fn cairo_serialize(__rust: &Self::RustType) -> Vec<starknet::core::types::Felt> {
         let mut __out: Vec<starknet::core::types::Felt> = vec![];
         __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.resource_id));
         __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize(&__rust.metadata_uri));
+        __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.metadata_hash));
         __out
     }
     fn cairo_deserialize(
@@ -651,7 +659,9 @@ impl cainome::cairo_serde::CairoSerde for ResourceMetadata {
         __offset += starknet::core::types::Felt::cairo_serialized_size(&resource_id);
         let metadata_uri = cainome::cairo_serde::ByteArray::cairo_deserialize(__felts, __offset)?;
         __offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&metadata_uri);
-        Ok(ResourceMetadata { resource_id, metadata_uri })
+        let metadata_hash = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?;
+        __offset += starknet::core::types::Felt::cairo_serialized_size(&metadata_hash);
+        Ok(ResourceMetadata { resource_id, metadata_uri, metadata_hash })
     }
 }
 #[derive(Clone, serde::Serialize, serde::Deserialize, PartialEq, Debug)]
@@ -1791,7 +1801,18 @@ impl TryFrom<&starknet::core::types::EmittedEvent> for Event {
                 }
             };
             data_offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&uri);
-            return Ok(Event::MetadataUpdate(MetadataUpdate { resource, uri }));
+            let hash =
+                match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) {
+                    Ok(v) => v,
+                    Err(e) => {
+                        return Err(format!(
+                            "Could not deserialize field {} for {}: {:?}",
+                            "hash", "MetadataUpdate", e
+                        ));
+                    }
+                };
+            data_offset += starknet::core::types::Felt::cairo_serialized_size(&hash);
+            return Ok(Event::MetadataUpdate(MetadataUpdate { resource, uri, hash }));
         }
         let selector = event.keys[0];
         if selector
@@ -2660,7 +2681,18 @@ impl TryFrom<&starknet::core::types::Event> for Event {
                 }
             };
             data_offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&uri);
-            return Ok(Event::MetadataUpdate(MetadataUpdate { resource, uri }));
+            let hash =
+                match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) {
+                    Ok(v) => v,
+                    Err(e) => {
+                        return Err(format!(
+                            "Could not deserialize field {} for {}: {:?}",
+                            "hash", "MetadataUpdate", e
+                        ));
+                    }
+                };
+            data_offset += starknet::core::types::Felt::cairo_serialized_size(&hash);
+            return Ok(Event::MetadataUpdate(MetadataUpdate { resource, uri, hash }));
         }
         let selector = event.keys[0];
         if selector