feat: generate contracts for Dojo events

bin/sozo/tests/test_migrate.rs

@@ -45,7 +45,8 @@ async fn migrate_dry_run() {
 
     assert!(output.contains("Migration Strategy"));
     assert!(output.contains("# Base Contract"));
-    assert!(output.contains("# Models (10)"));
+    assert!(output.contains("# Models (8)"));
+    assert!(output.contains("# Events (2)"));
     assert!(output.contains("# World"));
     assert!(output.contains("# Contracts (4)"));
 }

crates/dojo-bindgen/src/lib.rs

@@ -184,7 +184,7 @@ fn filter_model_tokens(tokens: &TokenizedAbi) -> TokenizedAbi {
     // All types from introspect module can also be removed as the clients does not rely on them.
     // Events are also always empty at model contract level.
     fn skip_token(token: &Token) -> bool {
-        if token.type_path().starts_with("dojo::model::introspect") {
+        if token.type_path().starts_with("dojo::meta::introspect") {
             return true;
         }
 
@@ -246,7 +246,7 @@ mod tests {
         )
         .unwrap();
 
-        assert_eq!(data.models.len(), 10);
+        assert_eq!(data.models.len(), 8);
 
         assert_eq!(data.world.name, "dojo_example");
 

crates/dojo-core/src/event/event.cairo

@@ -0,0 +1,65 @@
+use starknet::SyscallResult;
+
+use dojo::meta::Layout;
+use dojo::meta::introspect::Ty;
+use dojo::world::IWorldDispatcher;
+
+pub trait Event<T> {
+    fn name() -> ByteArray;
+    fn namespace() -> ByteArray;
+    fn tag() -> ByteArray;
+
+    fn version() -> u8;
+
+    fn selector() -> felt252;
+    fn instance_selector(self: @T) -> felt252;
+
+    fn name_hash() -> felt252;
+    fn namespace_hash() -> felt252;
+
+    fn layout() -> Layout;
+    fn schema(self: @T) -> Ty;
+
+    fn packed_size() -> Option<usize>;
+    fn unpacked_size() -> Option<usize>;
+}
+
+#[starknet::interface]
+pub trait IEvent<T> {
+    fn name(self: @T) -> ByteArray;
+    fn namespace(self: @T) -> ByteArray;
+    fn tag(self: @T) -> ByteArray;
+
+    fn version(self: @T) -> u8;
+
+    fn selector(self: @T) -> felt252;
+    fn name_hash(self: @T) -> felt252;
+    fn namespace_hash(self: @T) -> felt252;
+
+    fn packed_size(self: @T) -> Option<usize>;
+    fn unpacked_size(self: @T) -> Option<usize>;
+
+    fn layout(self: @T) -> Layout;
+    fn schema(self: @T) -> Ty;
+}
+
+/// Deploys an event with the given [`ClassHash`] and retrieves it's name.
+/// Currently, the event is expected to already be declared by `sozo`.
+///
+/// # Arguments
+///
+/// * `salt` - A salt used to uniquely deploy the event.
+/// * `class_hash` - Class Hash of the event.
+pub fn deploy_and_get_metadata(
+    salt: felt252, class_hash: starknet::ClassHash
+) -> SyscallResult<(starknet::ContractAddress, ByteArray, felt252, ByteArray, felt252)> {
+    let (contract_address, _) = starknet::syscalls::deploy_syscall(
+        class_hash, salt, [].span(), false,
+    )?;
+    let event = IEventDispatcher { contract_address };
+    let name = event.name();
+    let selector = event.selector();
+    let namespace = event.namespace();
+    let namespace_hash = event.namespace_hash();
+    Result::Ok((contract_address, name, selector, namespace, namespace_hash))
+}

crates/dojo-core/src/lib.cairo

@@ -6,11 +6,20 @@ pub mod contract {
     pub mod upgradeable;
 }
 
-pub mod model {
+pub mod meta {
     pub mod introspect;
     pub mod layout;
     pub use layout::{Layout, FieldLayout};
+}
+
+pub mod event {
+    pub mod event;
+    pub use event::{
+        Event, IEvent, IEventDispatcher, IEventDispatcherTrait, deploy_and_get_metadata
+    };
+}
 
+pub mod model {
     pub mod model;
     pub use model::{
         Model, ModelIndex, ModelEntity, IModel, IModelDispatcher, IModelDispatcherTrait,
@@ -72,8 +81,11 @@ pub mod world {
 
 #[cfg(test)]
 mod tests {
-    mod model {
+    mod meta {
         mod introspect;
+    }
+
+    mod model {
         mod model;
     }
     mod storage {

crates/dojo-core/src/model/introspect.cairo → crates/dojo-core/src/meta/introspect.cairo

@@ -1,4 +1,4 @@
-use dojo::model::{Layout, FieldLayout};
+use dojo::meta::{Layout, FieldLayout};
 
 #[derive(Copy, Drop, Serde)]
 pub enum Ty {
@@ -240,9 +240,9 @@ pub impl Introspect_option<T, +Introspect<T>> of Introspect<Option<T>> {
     fn layout() -> Layout {
         Layout::Enum(
             [
-                dojo::model::FieldLayout { // Some
+                dojo::meta::FieldLayout { // Some
                  selector: 0, layout: Introspect::<T>::layout() },
-                dojo::model::FieldLayout { // None
+                dojo::meta::FieldLayout { // None
                  selector: 1, layout: Layout::Fixed([].span()) },
             ].span()
         )

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

@@ -8,8 +8,9 @@ use core::byte_array::ByteArray;
 use core::poseidon::poseidon_hash_span;
 use core::serde::Serde;
 
-use dojo::model::introspect::{Introspect, Ty, Struct, Member};
-use dojo::model::{Model, ModelIndex, Layout, FieldLayout};
+use dojo::meta::{Layout, FieldLayout};
+use dojo::meta::introspect::{Introspect, Ty, Struct, Member};
+use dojo::model::{Model, ModelIndex};
 use dojo::utils;
 use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait};
 
@@ -32,13 +33,9 @@ pub struct ResourceMetadata {
 
 #[generate_trait]
 pub impl ResourceMetadataImpl of ResourceMetadataTrait {
-    fn from_values(resource_id: felt252, ref values: Span<felt252>) -> ResourceMetadata {
-        let metadata_uri = Serde::<ByteArray>::deserialize(ref values);
-        if metadata_uri.is_none() {
-            panic!("Model `ResourceMetadata`: metadata_uri deserialization failed.");
-        }
-
-        ResourceMetadata { resource_id, metadata_uri: metadata_uri.unwrap() }
+    fn from_values(resource_id: felt252, ref values: Span<felt252>) -> Option<ResourceMetadata> {
+        let metadata_uri = Serde::<ByteArray>::deserialize(ref values)?;
+        Option::Some(ResourceMetadata { resource_id, metadata_uri })
     }
 }
 
@@ -49,7 +46,10 @@ pub impl ResourceMetadataModel of Model<ResourceMetadata> {
         };
 
         let mut values = world.entity(Self::selector(), ModelIndex::Keys(keys), Self::layout());
-        ResourceMetadataTrait::from_values(*keys.at(0), ref values)
+        match ResourceMetadataTrait::from_values(*keys.at(0), ref values) {
+            Option::Some(x) => x,
+            Option::None => { panic!("Model `ResourceMetadata`: deserialization failed.") }
+        }
     }
 
     fn set_model(self: @ResourceMetadata, world: IWorldDispatcher,) {
@@ -198,8 +198,8 @@ pub mod resource_metadata {
     use super::ResourceMetadata;
     use super::ResourceMetadataModel;
 
-    use dojo::model::introspect::{Introspect, Ty};
-    use dojo::model::Layout;
+    use dojo::meta::introspect::{Introspect, Ty};
+    use dojo::meta::Layout;
 
     #[storage]
     struct Storage {}

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

@@ -1,7 +1,7 @@
 use starknet::SyscallResult;
 
-use dojo::model::Layout;
-use dojo::model::introspect::Ty;
+use dojo::meta::Layout;
+use dojo::meta::introspect::Ty;
 use dojo::world::IWorldDispatcher;
 
 #[derive(Copy, Drop, Serde, Debug, PartialEq)]
@@ -16,7 +16,7 @@ pub enum ModelIndex {
 pub trait ModelEntity<T> {
     fn id(self: @T) -> felt252;
     fn values(self: @T) -> Span<felt252>;
-    fn from_values(entity_id: felt252, ref values: Span<felt252>) -> T;
+    fn from_values(entity_id: felt252, ref values: Span<felt252>) -> Option<T>;
     // Get is always used with the trait path, which results in no ambiguity for the compiler.
     fn get(world: IWorldDispatcher, entity_id: felt252) -> T;
     // Update and delete can be used directly on the entity, which results in ambiguity.

crates/dojo-core/src/storage/layout.cairo

@@ -1,4 +1,4 @@
-use dojo::model::{Layout, FieldLayout};
+use dojo::meta::{Layout, FieldLayout};
 use dojo::utils::{combine_key, find_field_layout};
 
 use super::database;

crates/dojo-core/src/tests/base.cairo

@@ -220,7 +220,7 @@ mod invalid_model_world {
 #[test]
 #[available_gas(6000000)]
 #[should_panic(
-    expected: ("Resource `dojo-invalid_model` is already registered", 'ENTRYPOINT_FAILED',)
+    expected: ("Model `dojo-invalid_model` is already registered", 'ENTRYPOINT_FAILED',)
 )]
 fn test_deploy_from_world_invalid_model() {
     let world = deploy_world();

crates/dojo-core/src/tests/benchmarks.cairo

@@ -12,8 +12,9 @@ use starknet::storage_access::{
 };
 use starknet::syscalls::{storage_read_syscall, storage_write_syscall};
 
-use dojo::model::{Model, Layout, ModelIndex};
-use dojo::model::introspect::Introspect;
+use dojo::meta::Layout;
+use dojo::model::{Model, ModelIndex};
+use dojo::meta::introspect::Introspect;
 use dojo::storage::{database, storage};
 use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait};
 

crates/dojo-core/src/tests/model/introspect.cairo → crates/dojo-core/src/tests/meta/introspect.cairo

@@ -1,5 +1,5 @@
-use dojo::model::introspect::Introspect;
-use dojo::model::{Layout, FieldLayout};
+use dojo::meta::introspect::Introspect;
+use dojo::meta::{Layout, FieldLayout};
 
 #[derive(Drop, Introspect)]
 struct Base {

crates/dojo-core/src/tests/model/model.cairo

@@ -35,14 +35,16 @@ fn test_from_values() {
     let mut values = [3, 4].span();
 
     let model_entity = ModelEntity::<FooEntity>::from_values(1, ref values);
+    assert!(model_entity.is_some());
+    let model_entity = model_entity.unwrap();
     assert!(model_entity.__id == 1 && model_entity.v1 == 3 && model_entity.v2 == 4);
 }
 
 #[test]
-#[should_panic(expected: "ModelEntity `FooEntity`: deserialization failed.")]
 fn test_from_values_bad_data() {
     let mut values = [3].span();
-    let _ = ModelEntity::<FooEntity>::from_values(1, ref values);
+    let res = ModelEntity::<FooEntity>::from_values(1, ref values);
+    assert!(res.is_none());
 }
 
 #[test]

crates/dojo-core/src/tests/world/entities.cairo

@@ -2,8 +2,9 @@ use core::array::{ArrayTrait, SpanTrait};
 
 use starknet::{contract_address_const, ContractAddress};
 
-use dojo::model::{ModelIndex, Layout, FieldLayout, Model};
-use dojo::model::introspect::Introspect;
+use dojo::meta::{Layout, FieldLayout};
+use dojo::model::{ModelIndex, Model};
+use dojo::meta::introspect::Introspect;
 use dojo::storage::database::MAX_ARRAY_LENGTH;
 use dojo::utils::entity_id_from_keys;
 use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait, world};

crates/dojo-core/src/tests/world/resources.cairo

@@ -237,7 +237,7 @@ fn test_upgrade_model_from_model_writer() {
 }
 
 #[test]
-#[should_panic(expected: ("Resource `dojo-Foo` is already registered", 'ENTRYPOINT_FAILED',))]
+#[should_panic(expected: ("Model `dojo-Foo` is already registered", 'ENTRYPOINT_FAILED',))]
 fn test_upgrade_model_from_random_account() {
     let bob = starknet::contract_address_const::<0xb0b>();
     let alice = starknet::contract_address_const::<0xa11ce>();

crates/dojo-core/src/utils/utils.cairo

@@ -4,7 +4,7 @@ use core::option::Option;
 use core::poseidon::poseidon_hash_span;
 use core::serde::Serde;
 
-use dojo::model::{Layout, FieldLayout};
+use dojo::meta::{Layout, FieldLayout};
 
 /// Compute the poseidon hash of a serialized ByteArray
 pub fn bytearray_hash(data: @ByteArray) -> felt252 {

crates/dojo-core/src/world/errors.cairo

@@ -28,12 +28,20 @@ pub fn no_namespace_write_access(caller: ContractAddress, namespace: @ByteArray)
     format!("Caller `{:?}` has no write access on namespace `{}`", caller, namespace)
 }
 
+pub fn event_already_registered(namespace: @ByteArray, name: @ByteArray) -> ByteArray {
+    format!("Event `{}-{}` is already registered", namespace, name)
+}
+
+pub fn event_not_registered(namespace: @ByteArray, name: @ByteArray) -> ByteArray {
+    format!("Event `{}-{}` is not registered", namespace, name)
+}
+
 pub fn model_already_registered(namespace: @ByteArray, name: @ByteArray) -> ByteArray {
-    format!("Resource `{}-{}` is already registered", namespace, name)
+    format!("Model `{}-{}` is already registered", namespace, name)
 }
 
 pub fn model_not_registered(namespace: @ByteArray, name: @ByteArray) -> ByteArray {
-    format!("Resource `{}-{}` is not registered", namespace, name)
+    format!("Model `{}-{}` is not registered", namespace, name)
 }
 
 pub fn resource_not_registered(resource: felt252) -> ByteArray {