rename use_legacy_model_storage() to use_legacy_storage() as it's onl…

…y for models

crates/dojo/core-cairo-test/Scarb.lock

@@ -3,7 +3,7 @@ version = 1
 
 [[package]]
 name = "dojo"
-version = "1.2.1"
+version = "1.2.2"
 dependencies = [
  "dojo_plugin",
 ]

crates/dojo/core-cairo-test/src/tests/expanded/selector_attack.cairo

@@ -60,5 +60,9 @@ pub mod attacker_model {
                 unpacked_size: Self::unpacked_size(self),
             }
         }
+
+        fn use_legacy_storage(self: @ContractState) -> bool {
+            false
+        }
     }
 }

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

@@ -97,6 +97,10 @@ pub mod foo_invalid_name {
                 unpacked_size: Self::unpacked_size(self),
             }
         }
+
+        fn use_legacy_storage(self: @ContractState) -> bool {
+            false
+        }
     }
 }
 

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

@@ -37,7 +37,7 @@ pub impl IModelImpl<TContractState, M, +Model<M>> of IModel<TContractState> {
         Model::<M>::definition()
     }
 
-    fn use_legacy_model_storage(self: @TContractState) -> bool {
-        Model::<M>::use_legacy_model_storage()
+    fn use_legacy_storage(self: @TContractState) -> bool {
+        Model::<M>::use_legacy_storage()
     }
 }

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

@@ -20,7 +20,7 @@ pub enum ModelIndex {
 pub trait ModelDefinition<T> {
     fn name() -> ByteArray;
     fn layout() -> Layout;
-    fn use_legacy_model_storage() -> bool;
+    fn use_legacy_storage() -> bool;
     fn schema() -> Struct;
     fn size() -> Option<usize>;
 }

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

@@ -7,5 +7,5 @@ pub trait IModel<T> {
     fn unpacked_size(self: @T) -> Option<usize>;
     fn packed_size(self: @T) -> Option<usize>;
     fn definition(self: @T) -> dojo::model::ModelDef;
-    fn use_legacy_model_storage(self: @T) -> bool;
+    fn use_legacy_storage(self: @T) -> bool;
 }

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

@@ -81,9 +81,9 @@ pub trait Model<M> {
     fn layout() -> Layout;
     /// Returns the layout of a field in the model.
     fn field_layout(field_selector: felt252) -> Option<Layout>;
-    /// Indicates if the model uses the legacy model storage (true), or
+    /// Indicates if the model uses the legacy storage (true), or
     /// the new one (false).
-    fn use_legacy_model_storage() -> bool;
+    fn use_legacy_storage() -> bool;
     /// Returns the unpacked size of the model. Only applicable for fixed size models.
     fn unpacked_size() -> Option<usize>;
     /// Returns the packed size of the model. Only applicable for fixed size models.
@@ -151,8 +151,8 @@ pub impl ModelImpl<M, +ModelParser<M>, +ModelDefinition<M>, +Serde<M>, +Drop<M>>
         find_model_field_layout(Self::layout(), field_selector)
     }
 
-    fn use_legacy_model_storage() -> bool {
-        ModelDefinition::<M>::use_legacy_model_storage()
+    fn use_legacy_storage() -> bool {
+        ModelDefinition::<M>::use_legacy_storage()
     }
 
     fn schema() -> Struct {

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

@@ -30,7 +30,7 @@ pub mod m_$model_type$_definition {
         }
 
         #[inline(always)]
-        fn use_legacy_model_storage() -> bool {
+        fn use_legacy_storage() -> bool {
             $use_legacy_storage$
         }
 

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

@@ -670,12 +670,12 @@ impl<A: starknet::accounts::ConnectedAccount + Sync> ModelContract<A> {
     }
     #[allow(clippy::ptr_arg)]
     #[allow(clippy::too_many_arguments)]
-    pub fn use_legacy_model_storage(&self) -> cainome::cairo_serde::call::FCall<A::Provider, bool> {
+    pub fn use_legacy_storage(&self) -> cainome::cairo_serde::call::FCall<A::Provider, bool> {
         use cainome::cairo_serde::CairoSerde;
         let mut __calldata = vec![];
         let __call = starknet::core::types::FunctionCall {
             contract_address: self.address,
-            entry_point_selector: starknet::macros::selector!("use_legacy_model_storage"),
+            entry_point_selector: starknet::macros::selector!("use_legacy_storage"),
             calldata: __calldata,
         };
         cainome::cairo_serde::call::FCall::new(__call, self.provider())
@@ -799,12 +799,12 @@ impl<P: starknet::providers::Provider + Sync> ModelContractReader<P> {
     }
     #[allow(clippy::ptr_arg)]
     #[allow(clippy::too_many_arguments)]
-    pub fn use_legacy_model_storage(&self) -> cainome::cairo_serde::call::FCall<P, bool> {
+    pub fn use_legacy_storage(&self) -> cainome::cairo_serde::call::FCall<P, bool> {
         use cainome::cairo_serde::CairoSerde;
         let mut __calldata = vec![];
         let __call = starknet::core::types::FunctionCall {
             contract_address: self.address,
-            entry_point_selector: starknet::macros::selector!("use_legacy_model_storage"),
+            entry_point_selector: starknet::macros::selector!("use_legacy_storage"),
             calldata: __calldata,
         };
         cainome::cairo_serde::call::FCall::new(__call, self.provider())

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

@@ -58,7 +58,7 @@ pub trait ModelReader<E> {
     async fn packed_size(&self) -> Result<u32, E>;
     async fn unpacked_size(&self) -> Result<u32, E>;
     async fn layout(&self) -> Result<abigen::model::Layout, E>;
-    async fn use_legacy_model_storage(&self) -> Result<bool, E>;
+    async fn use_legacy_storage(&self) -> Result<bool, E>;
 }
 
 #[derive(Debug)]
@@ -206,8 +206,8 @@ where
         Ok(self.model_reader.layout().call().await?)
     }
 
-    async fn use_legacy_model_storage(&self) -> Result<bool, ModelError> {
-        Ok(self.model_reader.use_legacy_model_storage().call().await?)
+    async fn use_legacy_storage(&self) -> Result<bool, ModelError> {
+        Ok(self.model_reader.use_legacy_storage().call().await?)
     }
 }
 

crates/sozo/ops/src/model.rs

@@ -66,11 +66,11 @@ where
     };
     let schema = model.schema().await?;
 
-    // in old models, this `use_legacy_model_storage` function does not exist,
+    // in old models, this `use_legacy_storage` function does not exist,
     // so returns true.
     // If the error is due to unknown model or whatever, it will be catched by
     // a previous model reader call.
-    let use_legacy_storage = model.use_legacy_model_storage().await.unwrap_or(true);
+    let use_legacy_storage = model.use_legacy_storage().await.unwrap_or(true);
 
     deep_print_layout(&tag, &layout, &schema, use_legacy_storage);
 
@@ -123,11 +123,11 @@ where
     let schema = model.schema().await?;
     let values = model.entity_storage(&keys).await?;
 
-    // in old models, this `use_legacy_model_storage` function does not exist,
+    // in old models, this `use_legacy_storage` function does not exist,
     // so returns true.
     // If the error is due to unknown model or whatever, it will be catched by
     // a previous model reader call.
-    let use_legacy_storage = model.use_legacy_model_storage().await.unwrap_or(true);
+    let use_legacy_storage = model.use_legacy_storage().await.unwrap_or(true);
 
     Ok((format_deep_record(&schema, &keys, &values, use_legacy_storage), schema, values))
 }

crates/torii/sqlite/src/model.rs

@@ -114,7 +114,7 @@ impl ModelReader<Error> for ModelSQLReader {
         Ok(self.layout.clone())
     }
 
-    async fn use_legacy_model_storage(&self) -> Result<bool, Error> {
+    async fn use_legacy_storage(&self) -> Result<bool, Error> {
         // TODO: manage the new use_legacy_storage model function
         Ok(false)
     }