feat(lang): add the ability to get a WorldStorage from a namespace hash

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

@@ -3,7 +3,7 @@ version = 1
 
 [[package]]
 name = "dojo"
-version = "1.0.0-rc.0"
+version = "1.0.0"
 dependencies = [
  "dojo_plugin",
 ]

crates/dojo/core-cairo-test/src/lib.cairo

@@ -38,6 +38,7 @@ mod tests {
 
     mod expanded {
         pub(crate) mod selector_attack;
+        mod poseidon_hash_string;
     }
 
     mod helpers {

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

@@ -0,0 +1,61 @@
+use core::poseidon::poseidon_hash_span;
+
+
+#[test]
+fn test_poseidon_hash_string() {
+    let bytes: ByteArray = "foo";
+    let hash = poseidon_hash_string!("foo");
+    let mut array = array![];
+    bytes.serialize(ref array);
+    let computed = poseidon_hash_span(array.span());
+    assert_eq!(computed, hash);
+}
+#[test]
+fn test_poseidon_hash_string_empty() {
+    let bytes: ByteArray = "";
+    let hash = poseidon_hash_string!("");
+    let mut array = array![];
+    bytes.serialize(ref array);
+    let computed = poseidon_hash_span(array.span());
+    assert_eq!(computed, hash);
+}
+
+#[test]
+fn test_poseidon_hash_string_31() {
+    let bytes: ByteArray = "0123456789012345678901234567890";
+    let hash = poseidon_hash_string!("0123456789012345678901234567890");
+    let mut array = array![];
+    bytes.serialize(ref array);
+    let computed = poseidon_hash_span(array.span());
+    assert_eq!(computed, hash);
+}
+
+#[test]
+fn test_poseidon_hash_string_long() {
+    let bytes: ByteArray = "0123456789012345678901234567890foo";
+    let hash = poseidon_hash_string!("0123456789012345678901234567890foo");
+    let mut array = array![];
+    bytes.serialize(ref array);
+    let computed = poseidon_hash_span(array.span());
+    assert_eq!(computed, hash);
+}
+
+fn test_poseidon_hash_string_var() {
+    let bytes: ByteArray = "foo";
+    let bytes2: ByteArray = "foo";
+    let hash = poseidon_hash_string!(bytes);
+    let mut array = array![];
+    bytes2.serialize(ref array);
+    let computed = poseidon_hash_span(array.span());
+    assert_eq!(computed, hash);
+}
+
+fn test_poseidon_hash_string_ne() {
+    let bytes: ByteArray = "foo";
+    let hash = poseidon_hash_string!("bar");
+    let mut array = array![];
+    bytes.serialize(ref array);
+    let computed = poseidon_hash_span(array.span());
+    assert_ne!(computed, hash);
+}
+

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

@@ -32,6 +32,10 @@ pub impl WorldStorageInternalImpl of WorldStorageTrait {
         WorldStorage { dispatcher: world, namespace_hash }
     }
 
+    fn new_from_hash(self: @IWorldDispatcher, namespace_hash: felt252) -> WorldStorage {
+        WorldStorage { dispatcher: *self, namespace_hash }
+    }
+
     fn set_namespace(ref self: WorldStorage, namespace: @ByteArray) {
         self.namespace_hash = dojo::utils::bytearray_hash(namespace);
     }

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

@@ -29,6 +29,10 @@ pub mod $name$ {
         fn world(self: @ContractState, namespace: @ByteArray) -> dojo::world::storage::WorldStorage {
             dojo::world::WorldStorageTrait::new(self.world_provider.world_dispatcher(), namespace)
         }
+
+        fn world_from_hash(self: @ContractState, namespace_hash: felt252) -> dojo::world::storage::WorldStorage {
+            dojo::world::WorldStorageTrait::new_from_hash(@(self.world_provider.world_dispatcher()), namespace_hash)
+        }
     }
 
     $body$

crates/dojo/lang/src/cairo_plugin.rs

@@ -12,7 +12,7 @@ use super::attribute_macros::{
     DojoContract, DojoEvent, DojoModel, DOJO_CONTRACT_ATTR, DOJO_EVENT_ATTR, DOJO_MODEL_ATTR,
 };
 use super::derive_macros::{dojo_derive_all, DOJO_INTROSPECT_DERIVE, DOJO_PACKED_DERIVE};
-use super::inline_macros::SelectorFromTagMacro;
+use super::inline_macros::{PoseidonHashStringMacro, SelectorFromTagMacro};
 
 // #[cfg(test)]
 // #[path = "plugin_test.rs"]
@@ -26,6 +26,7 @@ pub fn dojo_plugin_suite() -> PluginSuite {
     let mut suite = PluginSuite::default();
 
     suite.add_plugin::<BuiltinDojoPlugin>().add_inline_macro_plugin::<SelectorFromTagMacro>();
+    suite.add_plugin::<BuiltinDojoPlugin>().add_inline_macro_plugin::<PoseidonHashStringMacro>();
 
     suite
 }

crates/dojo/lang/src/inline_macros/mod.rs

@@ -12,6 +12,7 @@ pub mod delete;
 pub mod emit;
 pub mod get;
 pub mod get_models_test_class_hashes;
+pub mod poseidon_hash_string;
 pub mod selector_from_tag;
 pub mod set;
 pub mod spawn_test_world;
@@ -21,6 +22,7 @@ pub use delete::DeleteMacro;
 pub use emit::EmitMacro;
 pub use get::GetMacro;
 pub use get_models_test_class_hashes::GetModelsTestClassHashes;
+pub use poseidon_hash_string::PoseidonHashStringMacro;
 pub use selector_from_tag::SelectorFromTagMacro;
 pub use set::SetMacro;
 pub use spawn_test_world::SpawnTestWorld;

crates/dojo/lang/src/inline_macros/poseidon_hash_string.rs

@@ -0,0 +1,62 @@
+use cairo_lang_defs::patcher::PatchBuilder;
+use cairo_lang_defs::plugin::{
+    InlineMacroExprPlugin, InlinePluginResult, MacroPluginMetadata, NamedPlugin, PluginDiagnostic,
+    PluginGeneratedFile,
+};
+use cairo_lang_defs::plugin_utils::unsupported_bracket_diagnostic;
+use cairo_lang_diagnostics::Severity;
+use cairo_lang_syntax::node::{ast, TypedStablePtr, TypedSyntaxNode};
+use dojo_types::naming;
+
+#[derive(Debug, Default)]
+pub struct PoseidonHashStringMacro;
+
+impl NamedPlugin for PoseidonHashStringMacro {
+    const NAME: &'static str = "poseidon_hash_string";
+}
+
+impl InlineMacroExprPlugin for PoseidonHashStringMacro {
+    fn generate_code(
+        &self,
+        db: &dyn cairo_lang_syntax::node::db::SyntaxGroup,
+        syntax: &ast::ExprInlineMacro,
+        _metadata: &MacroPluginMetadata<'_>,
+    ) -> InlinePluginResult {
+        let ast::WrappedArgList::ParenthesizedArgList(arg_list) = syntax.arguments(db) else {
+            return unsupported_bracket_diagnostic(db, syntax);
+        };
+
+        let args = arg_list.arguments(db).elements(db);
+
+        if args.len() != 1 {
+            return InlinePluginResult {
+                code: None,
+                diagnostics: vec![PluginDiagnostic {
+                    stable_ptr: syntax.stable_ptr().untyped(),
+                    message: "Invalid arguments. Expected \"poseidon_hash_string!(\"tag\")\""
+                        .to_string(),
+                    severity: Severity::Error,
+                }],
+            };
+        }
+
+        let tag = &args[0].as_syntax_node().get_text(db).replace('\"', "");
+
+        let selector = naming::compute_bytearray_hash(tag);
+
+        let mut builder = PatchBuilder::new(db, syntax);
+        builder.add_str(&format!("{:#64x}", selector));
+
+        let (code, code_mappings) = builder.build();
+
+        InlinePluginResult {
+            code: Some(PluginGeneratedFile {
+                name: "poseidon_hash_string_macro".into(),
+                content: code,
+                code_mappings,
+                aux_data: None,
+            }),
+            diagnostics: vec![],
+        }
+    }
+}

crates/dojo/lang/src/semantics/tests.rs

@@ -22,6 +22,8 @@ test_file_test!(
         get_models_test_class_hashes: "get_models_test_class_hashes",
 
         spawn_test_world: "spawn_test_world",
+
+        poseidon_hash_string: "poseidon_hash_string",
     },
     test_semantics
 );

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

@@ -203,13 +203,17 @@ pub mod actions {
         fn world_default(self: @ContractState) -> dojo::world::WorldStorage {
             self.world(@"ns")
         }
+
+        fn world_default_from_hash(self: @ContractState) -> dojo::world::WorldStorage {
+            self.world_from_hash(poseidon_hash_string!("ns"))
+        }
     }
 }
 
 #[cfg(test)]
 mod tests {
     use dojo::model::{ModelStorage, ModelValueStorage, ModelStorageTest};
-    use dojo::world::WorldStorageTrait;
+    use dojo::world::{WorldStorageTrait};
     use dojo_cairo_test::{
         spawn_test_world, NamespaceDef, TestResource, ContractDefTrait, ContractDef,
         WorldStorageTestTrait
@@ -306,4 +310,16 @@ mod tests {
         assert(new_position.vec.x == initial_position.vec.x + 1, 'position x is wrong');
         assert(new_position.vec.y == initial_position.vec.y, 'position y is wrong');
     }
+
+    #[test]
+    #[available_gas(30000000)]
+    fn test_world_from_hash() {
+        let ndef = namespace_def();
+        let mut world = spawn_test_world([ndef].span());
+        world.sync_perms_and_inits(contract_defs());
+        let hash: felt252 = poseidon_hash_string!("ns");
+        let storage = world.dispatcher.new_from_hash(hash);
+        assert_eq!(storage.namespace_hash, world.namespace_hash);
+        assert_eq!(storage.dispatcher.contract_address, world.dispatcher.contract_address);
+    }
 }