Updated functions to clear up naming with serialized

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

@@ -54,15 +54,15 @@ fn test_values() {
     let mvalues = FooValue { v1: 3, v2: 4 };
     let expected_values = [3, 4].span();
 
-    let values = mvalues.values();
+    let values = mvalues.serialized_values();
     assert!(expected_values == values);
 }
 
 #[test]
 fn test_from_values() {
     let mut values = [3, 4].span();
 
-    let model_values: Option<FooValue> = ModelValue::<FooValue>::from_values(1, ref values);
+    let model_values: Option<FooValue> = ModelValue::<FooValue>::from_serialized(1, ref values);
     assert!(model_values.is_some());
     let model_values = model_values.unwrap();
     assert!(model_values.v1 == 3 && model_values.v2 == 4);
@@ -71,7 +71,7 @@ fn test_from_values() {
 #[test]
 fn test_from_values_bad_data() {
     let mut values = [3].span();
-    let res: Option<FooValue> = ModelValue::<FooValue>::from_values(1, ref values);
+    let res: Option<FooValue> = ModelValue::<FooValue>::from_serialized(1, ref values);
     assert!(res.is_none());
 }
 
@@ -83,7 +83,7 @@ fn test_read_and_update_model_value() {
     world.write_model(@foo);
 
     let entity_id = foo.entity_id();
-    let mut model_value: FooValue = world.read_value(foo.key());
+    let mut model_value: FooValue = world.read_value(foo.keys());
     assert_eq!(model_value.v1, foo.v1);
     assert_eq!(model_value.v2, foo.v2);
 
@@ -92,7 +92,7 @@ fn test_read_and_update_model_value() {
 
     world.write_value_from_id(entity_id, @model_value);
 
-    let read_values: FooValue = world.read_value(foo.key());
+    let read_values: FooValue = world.read_value(foo.keys());
     assert!(read_values.v1 == model_value.v1 && read_values.v2 == model_value.v2);
 }
 
@@ -153,20 +153,20 @@ fn test_delete_from_model() {
 }
 
 #[test]
-fn test_model_ptr_from_key() {
+fn test_model_ptr_from_keys() {
     let mut world = spawn_foo_world();
     let foo = Foo { k1: 1, k2: 2, v1: 3, v2: 4 };
-    let ptr = Model::<Foo>::ptr_from_key(foo.key());
+    let ptr = Model::<Foo>::ptr_from_keys(foo.keys());
     world.write_model(@foo);
     let v1 = world.read_member(ptr, selector!("v1"));
     assert!(foo.v1 == v1);
 }
 
 #[test]
-fn test_model_ptr_from_keys() {
+fn test_model_ptr_from_serialized_keys() {
     let mut world = spawn_foo_world();
     let foo = Foo { k1: 1, k2: 2, v1: 3, v2: 4 };
-    let ptr = Model::<Foo>::ptr_from_keys(foo.keys());
+    let ptr = Model::<Foo>::ptr_from_serialized_keys(foo.serialized_keys());
     world.write_model(@foo);
     let v1 = world.read_member(ptr, selector!("v1"));
     assert!(foo.v1 == v1);

crates/dojo/core-cairo-test/src/tests/utils/key.cairo

@@ -1,9 +1,12 @@
-use dojo::utils::{entity_id_from_keys, combine_key};
+use dojo::utils::{entity_id_from_serialized_keys, combine_key};
 
 #[test]
 fn test_entity_id_from_keys() {
     let keys = [1, 2, 3].span();
-    assert(entity_id_from_keys(keys) == core::poseidon::poseidon_hash_span(keys), 'bad entity ID');
+    assert(
+        entity_id_from_serialized_keys(keys) == core::poseidon::poseidon_hash_span(keys),
+        'bad entity ID'
+    );
 }
 
 #[test]

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

@@ -13,8 +13,8 @@ pub trait Event<T> {
     fn definition() -> EventDefinition;
     fn layout() -> Layout;
     fn schema() -> Struct;
-    fn keys(self: @T) -> Span<felt252>;
-    fn values(self: @T) -> Span<felt252>;
+    fn serialized_keys(self: @T) -> Span<felt252>;
+    fn serialized_values(self: @T) -> Span<felt252>;
     /// Returns the selector of the event computed for the given namespace hash.
     fn selector(namespace_hash: felt252) -> felt252;
 }

crates/dojo/core/src/lib.cairo

@@ -70,7 +70,7 @@ pub mod utils {
     pub use hash::{bytearray_hash, selector_from_names, selector_from_namespace_and_name};
 
     pub mod key;
-    pub use key::{entity_id_from_keys, combine_key, entity_id_from_key};
+    pub use key::{entity_id_from_serialized_keys, combine_key, entity_id_from_keys};
 
     pub mod layout;
     pub use layout::{find_field_layout, find_model_field_layout};

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

@@ -1,6 +1,6 @@
 use dojo::{
     meta::{Layout, introspect::Struct, layout::compute_packed_size},
-    utils::{entity_id_from_keys, find_model_field_layout, entity_id_from_key}
+    utils::{entity_id_from_serialized_keys, find_model_field_layout, entity_id_from_keys}
 };
 
 use super::{ModelDefinition, ModelDef};
@@ -30,15 +30,15 @@ pub trait ModelParser<M> {
 /// It provides a standardized way to interact with models.
 pub trait Model<M> {
     /// Parses the key from the given model, where `K` is a type containing the keys of the model.
-    fn key<K, +KeyParser<M, K>>(self: @M) -> K;
+    fn keys<K, +KeyParser<M, K>>(self: @M) -> K;
     /// Returns the entity id of the model.
     fn entity_id(self: @M) -> felt252;
     /// Returns the keys of the model.
-    fn keys(self: @M) -> Span<felt252>;
+    fn serialized_keys(self: @M) -> Span<felt252>;
     /// Returns the values of the model.
-    fn values(self: @M) -> Span<felt252>;
+    fn serialized_values(self: @M) -> Span<felt252>;
     /// Constructs a model from the given keys and values.
-    fn from_values(ref keys: Span<felt252>, ref values: Span<felt252>) -> Option<M>;
+    fn from_serialized(ref keys: Span<felt252>, ref values: Span<felt252>) -> Option<M>;
     /// Returns the name of the model. (TODO: internalizing the name_hash could reduce poseidon
     /// costs).
     fn name() -> ByteArray;
@@ -59,33 +59,33 @@ pub trait Model<M> {
     /// Returns the selector of the model computed for the given namespace hash.
     fn selector(namespace_hash: felt252) -> felt252;
     /// Returns the pointer to the model from the key.
-    fn ptr_from_key<K, +Serde<K>, +Drop<K>>(key: K) -> ModelPtr<M>;
+    fn ptr_from_keys<K, +Serde<K>, +Drop<K>>(keys: K) -> ModelPtr<M>;
     /// Returns the pointer to the model from the keys.
-    fn ptr_from_keys(keys: Span<felt252>) -> ModelPtr<M>;
+    fn ptr_from_serialized_keys(keys: Span<felt252>) -> ModelPtr<M>;
     /// Returns the pointer to the model from the entity id.
     fn ptr_from_id(entity_id: felt252) -> ModelPtr<M>;
     /// Returns the ptr of the model.
     fn ptr(self: @M) -> ModelPtr<M>;
 }
 
 pub impl ModelImpl<M, +ModelParser<M>, +ModelDefinition<M>, +Serde<M>> of Model<M> {
-    fn key<K, +KeyParser<M, K>>(self: @M) -> K {
+    fn keys<K, +KeyParser<M, K>>(self: @M) -> K {
         KeyParser::<M, K>::parse_key(self)
     }
 
     fn entity_id(self: @M) -> felt252 {
-        entity_id_from_keys(Self::keys(self))
+        entity_id_from_serialized_keys(Self::serialized_keys(self))
     }
 
-    fn keys(self: @M) -> Span<felt252> {
+    fn serialized_keys(self: @M) -> Span<felt252> {
         ModelParser::<M>::serialize_keys(self)
     }
 
-    fn values(self: @M) -> Span<felt252> {
+    fn serialized_values(self: @M) -> Span<felt252> {
         ModelParser::<M>::serialize_values(self)
     }
 
-    fn from_values(ref keys: Span<felt252>, ref values: Span<felt252>) -> Option<M> {
+    fn from_serialized(ref keys: Span<felt252>, ref values: Span<felt252>) -> Option<M> {
         let mut serialized: Array<felt252> = keys.into();
         serialized.append_span(values);
         let mut span = serialized.span();
@@ -135,12 +135,12 @@ pub impl ModelImpl<M, +ModelParser<M>, +ModelDefinition<M>, +Serde<M>> of Model<
         }
     }
 
-    fn ptr_from_key<K, +Serde<K>, +Drop<K>>(key: K) -> ModelPtr<M> {
-        ModelPtr { id: entity_id_from_key(@key) }
+    fn ptr_from_keys<K, +Serde<K>, +Drop<K>>(keys: K) -> ModelPtr<M> {
+        ModelPtr { id: entity_id_from_keys(@keys) }
     }
 
-    fn ptr_from_keys(keys: Span<felt252>) -> ModelPtr<M> {
-        ModelPtr { id: entity_id_from_keys(keys) }
+    fn ptr_from_serialized_keys(keys: Span<felt252>) -> ModelPtr<M> {
+        ModelPtr { id: entity_id_from_serialized_keys(keys) }
     }
 
     fn ptr_from_id(entity_id: felt252) -> ModelPtr<M> {

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

@@ -13,9 +13,9 @@ pub trait ModelValueParser<V> {
 pub trait ModelValue<V> {
     /// Returns a span of values associated with the entity, every field of a model
     /// that is not a key.
-    fn values(self: @V) -> Span<felt252>;
+    fn serialized_values(self: @V) -> Span<felt252>;
     /// Constructs a model value from its identifier and values.
-    fn from_values(entity_id: felt252, ref values: Span<felt252>) -> Option<V>;
+    fn from_serialized(entity_id: felt252, ref values: Span<felt252>) -> Option<V>;
     /// Returns the name of the model value type.
     fn name() -> ByteArray;
     /// Returns the layout of the model value type.
@@ -27,11 +27,11 @@ pub trait ModelValue<V> {
 }
 
 pub impl ModelValueImpl<V, +Serde<V>, +ModelDefinition<V>, +ModelValueParser<V>> of ModelValue<V> {
-    fn values(self: @V) -> Span<felt252> {
+    fn serialized_values(self: @V) -> Span<felt252> {
         ModelValueParser::<V>::serialize_values(self)
     }
 
-    fn from_values(entity_id: felt252, ref values: Span<felt252>) -> Option<V> {
+    fn from_serialized(entity_id: felt252, ref values: Span<felt252>) -> Option<V> {
         let mut serialized: Array<felt252> = array![];
         serialized.append_span(values);
         let mut span = serialized.span();

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

@@ -14,7 +14,7 @@ pub trait ModelStorage<S, M> {
     fn write_models(ref self: S, models: Span<@M>);
 
     /// Retrieves a model of type `M` using the provided key of type `K`.
-    fn read_model<K, +Drop<K>, +Serde<K>>(self: @S, key: K) -> M;
+    fn read_model<K, +Drop<K>, +Serde<K>>(self: @S, keys: K) -> M;
 
     /// Retrieves multiple models of type `M` using the provided keys of type `K`.
     /// Returnes an array to ensure the user can consume the models, even if the type is not
@@ -50,7 +50,7 @@ pub trait ModelStorage<S, M> {
 /// A `ModelValueStorage` trait that abstracts where the storage is.
 pub trait ModelValueStorage<S, V> {
     /// Retrieves a model value of type `V` using the provided key of type `K`.
-    fn read_value<K, +Drop<K>, +Serde<K>, +ModelValueKey<V, K>>(self: @S, key: K) -> V;
+    fn read_value<K, +Drop<K>, +Serde<K>, +ModelValueKey<V, K>>(self: @S, keys: K) -> V;
 
     /// Retrieves multiple model values of type `V` using the provided keys of type `K`.
     fn read_values<K, +Drop<K>, +Serde<K>, +ModelValueKey<V, K>>(
@@ -64,7 +64,7 @@ pub trait ModelValueStorage<S, V> {
     fn read_values_from_ids(self: @S, entity_ids: Span<felt252>) -> Array<V>;
 
     /// Updates a model value of type `V`.
-    fn write_value<K, +Drop<K>, +Serde<K>, +ModelValueKey<V, K>>(ref self: S, key: K, value: @V);
+    fn write_value<K, +Drop<K>, +Serde<K>, +ModelValueKey<V, K>>(ref self: S, keys: K, value: @V);
 
     /// Updates multiple model values of type `V`.
     fn write_values<K, +Drop<K>, +Serde<K>, +ModelValueKey<V, K>>(
@@ -102,7 +102,7 @@ pub trait ModelStorageTest<S, M> {
 pub trait ModelValueStorageTest<S, V> {
     /// Updates a model value of type `V`.
     fn write_value_test<K, +Drop<K>, +Serde<K>, +ModelValueKey<V, K>>(
-        ref self: S, key: K, value: @V
+        ref self: S, keys: K, value: @V
     );
     /// Updates multiple model values of type `V`.
     fn write_values_test<K, +Drop<K>, +Serde<K>, +ModelValueKey<V, K>>(

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

@@ -9,7 +9,7 @@ use dojo::utils::serialize_inline;
 /// # Returns
 ///
 /// The entity id.
-pub fn entity_id_from_keys(keys: Span<felt252>) -> felt252 {
+pub fn entity_id_from_serialized_keys(keys: Span<felt252>) -> felt252 {
     core::poseidon::poseidon_hash_span(keys)
 }
 
@@ -19,6 +19,6 @@ pub fn combine_key(parent_key: felt252, child_key: felt252) -> felt252 {
 }
 
 /// Computes the entity id from the key.
-pub fn entity_id_from_key<K, +Serde<K>>(key: @K) -> felt252 {
-    entity_id_from_keys(serialize_inline::<K>(key))
+pub fn entity_id_from_keys<K, +Serde<K>>(keys: @K) -> felt252 {
+    entity_id_from_serialized_keys(serialize_inline::<K>(keys))
 }

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

@@ -6,7 +6,7 @@ use dojo::model::{Model, ModelIndex, ModelValueKey, ModelValue, ModelStorage, Mo
 use dojo::event::{Event, EventStorage};
 use dojo::meta::Layout;
 use dojo::utils::{
-    entity_id_from_key, entity_id_from_keys, serialize_inline, find_model_field_layout,
+    entity_id_from_keys, entity_id_from_serialized_keys, serialize_inline, find_model_field_layout,
     deserialize_unwrap
 };
 use starknet::{ContractAddress, ClassHash};
@@ -58,22 +58,22 @@ pub impl EventStorageWorldStorageImpl<E, +Event<E>> of EventStorage<WorldStorage
         dojo::world::IWorldDispatcherTrait::emit_event(
             self.dispatcher,
             Event::<E>::selector(self.namespace_hash),
-            Event::<E>::keys(event),
-            Event::<E>::values(event),
+            Event::<E>::serialized_keys(event),
+            Event::<E>::serialized_values(event),
         );
     }
 }
 
 pub impl ModelStorageWorldStorageImpl<M, +Model<M>, +Drop<M>> of ModelStorage<WorldStorage, M> {
-    fn read_model<K, +Drop<K>, +Serde<K>>(self: @WorldStorage, key: K) -> M {
-        let mut keys = serialize_inline::<K>(@key);
+    fn read_model<K, +Drop<K>, +Serde<K>>(self: @WorldStorage, keys: K) -> M {
+        let mut keys = serialize_inline::<K>(@keys);
         let mut values = IWorldDispatcherTrait::entity(
             *self.dispatcher,
             Model::<M>::selector(*self.namespace_hash),
             ModelIndex::Keys(keys),
             Model::<M>::layout()
         );
-        match Model::<M>::from_values(ref keys, ref values) {
+        match Model::<M>::from_serialized(ref keys, ref values) {
             Option::Some(model) => model,
             Option::None => {
                 panic!(
@@ -108,7 +108,7 @@ pub impl ModelStorageWorldStorageImpl<M, +Model<M>, +Drop<M>> of ModelStorage<Wo
             let mut mk = serialize_inline::<K>(keys[i]);
             let mut mv = *all_values[i];
 
-            match Model::<M>::from_values(ref mk, ref mv) {
+            match Model::<M>::from_serialized(ref mk, ref mv) {
                 Option::Some(model) => models.append(model),
                 Option::None => {
                     panic!(
@@ -127,8 +127,8 @@ pub impl ModelStorageWorldStorageImpl<M, +Model<M>, +Drop<M>> of ModelStorage<Wo
         IWorldDispatcherTrait::set_entity(
             self.dispatcher,
             Model::<M>::selector(self.namespace_hash),
-            ModelIndex::Keys(Model::<M>::keys(model)),
-            Model::<M>::values(model),
+            ModelIndex::Keys(Model::<M>::serialized_keys(model)),
+            Model::<M>::serialized_values(model),
             Model::<M>::layout()
         );
     }
@@ -137,8 +137,8 @@ pub impl ModelStorageWorldStorageImpl<M, +Model<M>, +Drop<M>> of ModelStorage<Wo
         let mut keys: Array<ModelIndex> = array![];
         let mut values: Array<Span<felt252>> = array![];
         for m in models {
-            keys.append(ModelIndex::Keys(Model::<M>::keys(*m)));
-            values.append(Model::<M>::values(*m));
+            keys.append(ModelIndex::Keys(Model::<M>::serialized_keys(*m)));
+            values.append(Model::<M>::serialized_values(*m));
         };
 
         IWorldDispatcherTrait::set_entities(
@@ -154,7 +154,7 @@ pub impl ModelStorageWorldStorageImpl<M, +Model<M>, +Drop<M>> of ModelStorage<Wo
         IWorldDispatcherTrait::delete_entity(
             self.dispatcher,
             Model::<M>::selector(self.namespace_hash),
-            ModelIndex::Keys(Model::<M>::keys(model)),
+            ModelIndex::Keys(Model::<M>::serialized_keys(model)),
             Model::<M>::layout()
         );
     }
@@ -228,8 +228,8 @@ pub impl ModelStorageWorldStorageImpl<M, +Model<M>, +Drop<M>> of ModelStorage<Wo
 impl ModelValueStorageWorldStorageImpl<
     V, +ModelValue<V>, +Drop<V>
 > of dojo::model::ModelValueStorage<WorldStorage, V> {
-    fn read_value<K, +Drop<K>, +Serde<K>, +ModelValueKey<V, K>>(self: @WorldStorage, key: K) -> V {
-        Self::read_value_from_id(self, entity_id_from_key(@key))
+    fn read_value<K, +Drop<K>, +Serde<K>, +ModelValueKey<V, K>>(self: @WorldStorage, keys: K) -> V {
+        Self::read_value_from_id(self, entity_id_from_keys(@keys))
     }
 
     fn read_value_from_id(self: @WorldStorage, entity_id: felt252) -> V {
@@ -239,7 +239,7 @@ impl ModelValueStorageWorldStorageImpl<
             ModelIndex::Id(entity_id),
             ModelValue::<V>::layout()
         );
-        match ModelValue::<V>::from_values(entity_id, ref values) {
+        match ModelValue::<V>::from_serialized(entity_id, ref values) {
             Option::Some(entity) => entity,
             Option::None => {
                 panic!(
@@ -254,7 +254,7 @@ impl ModelValueStorageWorldStorageImpl<
     ) -> Array<V> {
         let mut entity_ids: Array<felt252> = array![];
         for k in keys {
-            entity_ids.append(entity_id_from_key(k));
+            entity_ids.append(entity_id_from_keys(k));
         };
 
         Self::read_values_from_ids(self, entity_ids.span())
@@ -283,7 +283,7 @@ impl ModelValueStorageWorldStorageImpl<
             let entity_id = *entity_ids[i];
             let mut v = *all_values[i];
 
-            match ModelValue::<V>::from_values(entity_id, ref v) {
+            match ModelValue::<V>::from_serialized(entity_id, ref v) {
                 Option::Some(value) => values.append(value),
                 Option::None => {
                     panic!(
@@ -299,14 +299,14 @@ impl ModelValueStorageWorldStorageImpl<
     }
 
     fn write_value<K, +Drop<K>, +Serde<K>, +ModelValueKey<V, K>>(
-        ref self: WorldStorage, key: K, value: @V
+        ref self: WorldStorage, keys: K, value: @V
     ) {
         IWorldDispatcherTrait::set_entity(
             self.dispatcher,
             ModelValue::<V>::selector(self.namespace_hash),
             // We need Id here to trigger the store update event.
-            ModelIndex::Id(entity_id_from_keys(serialize_inline::<K>(@key))),
-            ModelValue::<V>::values(value),
+            ModelIndex::Id(entity_id_from_serialized_keys(serialize_inline::<K>(@keys))),
+            ModelValue::<V>::serialized_values(value),
             ModelValue::<V>::layout()
         );
     }
@@ -316,7 +316,7 @@ impl ModelValueStorageWorldStorageImpl<
     ) {
         let mut ids: Array<felt252> = array![];
         for k in keys {
-            ids.append(entity_id_from_key(k));
+            ids.append(entity_id_from_keys(k));
         };
 
         Self::write_values_from_ids(ref self, ids.span(), values);
@@ -327,7 +327,7 @@ impl ModelValueStorageWorldStorageImpl<
             self.dispatcher,
             ModelValue::<V>::selector(self.namespace_hash),
             ModelIndex::Id(entity_id),
-            ModelValue::<V>::values(value),
+            ModelValue::<V>::serialized_values(value),
             ModelValue::<V>::layout()
         );
     }
@@ -343,7 +343,7 @@ impl ModelValueStorageWorldStorageImpl<
             }
 
             indexes.append(ModelIndex::Id(*entity_ids[i]));
-            all_values.append(ModelValue::<V>::values(*values[i]));
+            all_values.append(ModelValue::<V>::serialized_values(*values[i]));
 
             i += 1;
         };
@@ -369,8 +369,8 @@ pub impl EventStorageTestWorldStorageImpl<
         dojo::world::IWorldTestDispatcherTrait::emit_event_test(
             world_test,
             Event::<E>::selector(self.namespace_hash),
-            Event::<E>::keys(event),
-            Event::<E>::values(event),
+            Event::<E>::serialized_keys(event),
+            Event::<E>::serialized_values(event),
         );
     }
 }
@@ -388,8 +388,8 @@ pub impl ModelStorageTestWorldStorageImpl<
         dojo::world::IWorldTestDispatcherTrait::set_entity_test(
             world_test,
             Model::<M>::selector(self.namespace_hash),
-            ModelIndex::Keys(Model::keys(model)),
-            Model::<M>::values(model),
+            ModelIndex::Keys(Model::serialized_keys(model)),
+            Model::<M>::serialized_values(model),
             Model::<M>::layout()
         );
     }
@@ -408,7 +408,7 @@ pub impl ModelStorageTestWorldStorageImpl<
         dojo::world::IWorldTestDispatcherTrait::delete_entity_test(
             world_test,
             Model::<M>::selector(self.namespace_hash),
-            ModelIndex::Keys(Model::keys(model)),
+            ModelIndex::Keys(Model::serialized_keys(model)),
             Model::<M>::layout()
         );
     }
@@ -455,18 +455,17 @@ pub impl ModelValueStorageTestWorldStorageImpl<
     V, +ModelValue<V>
 > of dojo::model::ModelValueStorageTest<WorldStorage, V> {
     fn write_value_test<K, +Drop<K>, +Serde<K>, +ModelValueKey<V, K>>(
-        ref self: WorldStorage, key: K, value: @V
+        ref self: WorldStorage, keys: K, value: @V
     ) {
-        let keys = serialize_inline::<K>(@key);
-        Self::write_value_from_id_test(ref self, dojo::utils::entity_id_from_keys(keys), value);
+        Self::write_value_from_id_test(ref self, dojo::utils::entity_id_from_keys(@keys), value);
     }
 
     fn write_values_test<K, +Drop<K>, +Serde<K>, +ModelValueKey<V, K>>(
         ref self: WorldStorage, keys: Span<K>, values: Span<@V>
     ) {
         let mut ids: Array<felt252> = array![];
         for k in keys {
-            ids.append(entity_id_from_key(k));
+            ids.append(entity_id_from_keys(k));
         };
 
         Self::write_values_from_ids_test(ref self, ids.span(), values);
@@ -481,7 +480,7 @@ pub impl ModelValueStorageTestWorldStorageImpl<
             world_test,
             ModelValue::<V>::selector(self.namespace_hash),
             ModelIndex::Id(entity_id),
-            ModelValue::<V>::values(value),
+            ModelValue::<V>::serialized_values(value),
             ModelValue::<V>::layout()
         );
     }

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

@@ -46,7 +46,9 @@ pub mod world {
     };
     use dojo::model::{Model, ResourceMetadata, metadata, ModelIndex};
     use dojo::storage;
-    use dojo::utils::{entity_id_from_keys, bytearray_hash, selector_from_namespace_and_name};
+    use dojo::utils::{
+        entity_id_from_serialized_keys, bytearray_hash, selector_from_namespace_and_name
+    };
     use dojo::world::{IWorld, IUpgradeableWorld, Resource, ResourceIsNoneTrait};
     use super::Permission;
 
@@ -328,13 +330,13 @@ pub mod world {
 
             let mut values = storage::entity_model::read_model_entity(
                 metadata::resource_metadata_selector(internal_ns_hash),
-                entity_id_from_keys([resource_selector].span()),
+                entity_id_from_serialized_keys([resource_selector].span()),
                 Model::<ResourceMetadata>::layout()
             );
 
             let mut keys = [resource_selector].span();
 
-            match Model::<ResourceMetadata>::from_values(ref keys, ref values) {
+            match Model::<ResourceMetadata>::from_serialized(ref keys, ref values) {
                 Option::Some(x) => x,
                 Option::None => panic!("Model `ResourceMetadata`: deserialization failed.")
             }
@@ -347,8 +349,8 @@ pub mod world {
 
             storage::entity_model::write_model_entity(
                 metadata::resource_metadata_selector(internal_ns_hash),
-                entity_id_from_keys([metadata.resource_id].span()),
-                metadata.values(),
+                entity_id_from_serialized_keys([metadata.resource_id].span()),
+                metadata.serialized_values(),
                 Model::<ResourceMetadata>::layout()
             );
 
@@ -1172,7 +1174,7 @@ pub mod world {
         ) {
             match index {
                 ModelIndex::Keys(keys) => {
-                    let entity_id = entity_id_from_keys(keys);
+                    let entity_id = entity_id_from_serialized_keys(keys);
                     storage::entity_model::write_model_entity(
                         model_selector, entity_id, values, layout
                     );
@@ -1212,7 +1214,7 @@ pub mod world {
         ) {
             match index {
                 ModelIndex::Keys(keys) => {
-                    let entity_id = entity_id_from_keys(keys);
+                    let entity_id = entity_id_from_serialized_keys(keys);
                     storage::entity_model::delete_model_entity(model_selector, entity_id, layout);
                     self.emit(StoreDelRecord { selector: model_selector, entity_id });
                 },
@@ -1236,7 +1238,7 @@ pub mod world {
         ) -> Span<felt252> {
             match index {
                 ModelIndex::Keys(keys) => {
-                    let entity_id = entity_id_from_keys(keys);
+                    let entity_id = entity_id_from_serialized_keys(keys);
                     storage::entity_model::read_model_entity(model_selector, entity_id, layout)
                 },
                 ModelIndex::Id(entity_id) => {

crates/dojo/lang/src/attribute_macros/patches/event.patch.cairo

@@ -29,14 +29,14 @@ pub impl $type_name$DojoEventImpl of dojo::event::Event<$type_name$> {
     }
 
     #[inline(always)]
-    fn keys(self: @$type_name$) -> Span<felt252> {
+    fn serialized_keys(self: @$type_name$) -> Span<felt252> {
         let mut serialized = core::array::ArrayTrait::new();
         $serialized_keys$
         core::array::ArrayTrait::span(@serialized)
     }
 
     #[inline(always)]
-    fn values(self: @$type_name$) -> Span<felt252> {
+    fn serialized_values(self: @$type_name$) -> Span<felt252> {
         let mut serialized = core::array::ArrayTrait::new();
         $serialized_values$
         core::array::ArrayTrait::span(@serialized)

examples/spawn-and-move/src/actions.cairo

@@ -102,9 +102,9 @@ pub mod actions {
 
             // You can get the entity ID in different ways.
             // Using the `Model` Model::<YOUR_TYPE>::entity_id(@model).
-            // Or using `dojo::utils::entity_id_from_keys([player].span())`.
+            // Or using `dojo::utils::entity_id_from_serialized_keys([player].span())`.
             let player_felt: felt252 = player.into();
-            let move_id = dojo::utils::entity_id_from_keys([player_felt].span());
+            let move_id = dojo::utils::entity_id_from_serialized_keys([player_felt].span());
 
             let mut moves: MovesValue = world.read_value_from_id(move_id);
             moves.remaining -= 1;
@@ -258,7 +258,7 @@ mod tests {
 
         // Example using the entity id.
         let caller_felt: felt252 = caller.into();
-        let id = dojo::utils::entity_id_from_keys([caller_felt].span());
+        let id = dojo::utils::entity_id_from_serialized_keys([caller_felt].span());
         let mut position: PositionValue = world.read_value_from_id(id);
         assert(position.vec.x == 122, 'bad x');