feat: merge audit branch

Cargo.toml

@@ -136,6 +136,7 @@ itertools = "0.10.3"
 jsonrpsee = { version = "0.16.2", default-features = false }
 lazy_static = "1.4.0"
 metrics-process = "1.0.9"
+num-traits = { version = "0.2", default-features = false }
 once_cell = "1.0"
 parking_lot = "0.12.1"
 pretty_assertions = "1.2.1"

bin/sozo/src/commands/events.rs

@@ -101,10 +101,6 @@ fn extract_events(manifest: &Manifest) -> HashMap<String, Vec<Event>> {
         inner_helper(&mut events_map, abi);
     }
 
-    if let Some(abi) = manifest.executor.abi.clone() {
-        inner_helper(&mut events_map, abi);
-    }
-
     for contract in &manifest.contracts {
         if let Some(abi) = contract.abi.clone() {
             inner_helper(&mut events_map, abi);

bin/sozo/src/commands/model.rs

@@ -16,8 +16,8 @@ pub struct ModelArgs {
 
 #[derive(Debug, Subcommand)]
 pub enum ModelCommands {
-    #[command(about = "Retrieve the class hash of a model")]
-    ClassHash {
+    #[command(about = "Retrieve the contract address of a model")]
+    ContractAddress {
         #[arg(help = "The name of the model")]
         name: String,
 

bin/sozo/src/ops/migration/migration_test.rs

@@ -147,6 +147,5 @@ async fn migration_from_remote() {
     sequencer.stop().unwrap();
 
     assert_eq!(local_manifest.world.class_hash, remote_manifest.world.class_hash);
-    assert_eq!(local_manifest.executor.class_hash, remote_manifest.executor.class_hash);
     assert_eq!(local_manifest.models.len(), remote_manifest.models.len());
 }

bin/sozo/src/ops/migration/mod.rs

@@ -1,6 +1,7 @@
 use std::path::Path;
 
 use anyhow::{anyhow, bail, Context, Result};
+use dojo_world::contracts::abi::world::ResourceMetadata;
 use dojo_world::contracts::cairo_utils;
 use dojo_world::contracts::world::WorldContract;
 use dojo_world::manifest::{Manifest, ManifestError};
@@ -286,34 +287,6 @@ where
 {
     let ui = ws.config().ui();
 
-    match &strategy.executor {
-        Some(executor) => {
-            ui.print_header("# Executor");
-            deploy_contract(executor, "executor", vec![], migrator, &ui, &txn_config).await?;
-
-            // There is no world migration, so it exists already.
-            if strategy.world.is_none() {
-                let addr = strategy.world_address()?;
-                let InvokeTransactionResult { transaction_hash } =
-                    WorldContract::new(addr, &migrator)
-                        .set_executor(&executor.contract_address.into())
-                        .send()
-                        .await
-                        .map_err(|e| {
-                            ui.verbose(format!("{e:?}"));
-                            e
-                        })?;
-
-                TransactionWaiter::new(transaction_hash, migrator.provider()).await?;
-
-                ui.print_hidden_sub(format!("Updated at: {transaction_hash:#x}"));
-            }
-
-            ui.print_sub(format!("Contract address: {:#x}", executor.contract_address));
-        }
-        None => {}
-    };
-
     match &strategy.base {
         Some(base) => {
             ui.print_header("# Base Contract");
@@ -341,10 +314,7 @@ where
         Some(world) => {
             ui.print_header("# World");
 
-            let calldata = vec![
-                strategy.executor.as_ref().unwrap().contract_address,
-                strategy.base.as_ref().unwrap().diff.local,
-            ];
+            let calldata = vec![strategy.base.as_ref().unwrap().diff.local];
             deploy_contract(world, "world", calldata.clone(), migrator, &ui, &txn_config)
                 .await
                 .map_err(|e| {
@@ -358,11 +328,21 @@ where
             if let Some(meta) = metadata.as_ref().and_then(|inner| inner.world()) {
                 match meta.upload().await {
                     Ok(hash) => {
-                        let encoded_uri = cairo_utils::encode_uri(&format!("ipfs://{hash}"))?;
+                        let mut encoded_uri = cairo_utils::encode_uri(&format!("ipfs://{hash}"))?;
+
+                        // Metadata is expecting an array of capacity 3.
+                        if encoded_uri.len() < 3 {
+                            encoded_uri.extend(vec![FieldElement::ZERO; 3 - encoded_uri.len()]);
+                        }
+
+                        let world_metadata = ResourceMetadata {
+                            resource_id: FieldElement::ZERO,
+                            metadata_uri: encoded_uri,
+                        };
 
                         let InvokeTransactionResult { transaction_hash } =
                             WorldContract::new(world.contract_address, migrator)
-                                .set_metadata_uri(&FieldElement::ZERO, &encoded_uri)
+                                .set_metadata(&world_metadata)
                                 .send()
                                 .await
                                 .map_err(|e| {
@@ -382,6 +362,12 @@ where
         None => {}
     };
 
+    // We don't declare and register the model for Resource Metadata for two reasons:
+    // 1. Having the ModelRegistered event is occupying space for data that are redundant with
+    //    `MetadataUpdate` event.
+    // 2. This model is never used from outside world queries, only to set metadata. It should then
+    //    remain internal.
+
     register_models(strategy, migrator, &ui, txn_config.clone()).await?;
     deploy_contracts(strategy, migrator, &ui, txn_config).await?;
 

bin/sozo/src/ops/model.rs

@@ -8,7 +8,7 @@ use crate::commands::model::ModelCommands;
 
 pub async fn execute(command: ModelCommands, env_metadata: Option<Environment>) -> Result<()> {
     match command {
-        ModelCommands::ClassHash { name, world, starknet } => {
+        ModelCommands::ContractAddress { name, world, starknet } => {
             let world_address = world.address(env_metadata.as_ref())?;
             let provider = starknet.provider(env_metadata.as_ref())?;
 
@@ -17,7 +17,7 @@ pub async fn execute(command: ModelCommands, env_metadata: Option<Environment>)
 
             let model = world.model_reader(&name).await?;
 
-            println!("{:#x}", model.class_hash());
+            println!("{:#x}", model.contract_address());
         }
 
         ModelCommands::Schema { name, world, starknet, to_json } => {

bin/sozo/tests/test_data/manifest.json

@@ -843,6 +843,15 @@
     "writes": [],
     "computed": []
   },
+  "resource_metadata": {
+    "name": "",
+    "address": null,
+    "class_hash": "0x0",
+    "abi": null,
+    "reads": [],
+    "writes": [],
+    "computed": []
+  },
   "base": {
     "name": "dojo::base::base",
     "class_hash": "0x6c458453d35753703ad25632deec20a29faf8531942ec109e6eb0650316a2bc",
@@ -1569,4 +1578,4 @@
       ]
     }
   ]
-}
+}

crates/dojo-core/src/base_test.cairo

@@ -10,6 +10,8 @@ use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait};
 
 #[starknet::contract]
 mod contract_upgrade {
+    use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait, IWorldProvider};
+
     #[storage]
     struct Storage {}
 
@@ -27,6 +29,19 @@ mod contract_upgrade {
             'daddy'
         }
     }
+
+    #[abi(embed_v0)]
+    impl WorldProviderImpl of IWorldProvider<ContractState> {
+        fn world(self: @ContractState) -> IWorldDispatcher {
+            IWorldDispatcher { contract_address: starknet::contract_address_const::<'world'>() }
+        }
+    }
+}
+
+#[starknet::contract]
+mod contract_invalid_upgrade {
+    #[storage]
+    struct Storage {}
 }
 
 use contract_upgrade::{IQuantumLeapDispatcher, IQuantumLeapDispatcherTrait};
@@ -50,6 +65,18 @@ fn test_upgrade_from_world() {
     assert(quantum_dispatcher.plz_more_tps() == 'daddy', 'quantum leap failed');
 }
 
+#[test]
+#[available_gas(6000000)]
+#[should_panic(expected: ('class_hash not world provider', 'ENTRYPOINT_FAILED', 'ENTRYPOINT_FAILED'))]
+fn test_upgrade_from_world_not_world_provider() {
+    let world = deploy_world();
+
+    let base_address = world.deploy_contract('salt', base::TEST_CLASS_HASH.try_into().unwrap());
+    let new_class_hash: ClassHash = contract_invalid_upgrade::TEST_CLASS_HASH.try_into().unwrap();
+
+    world.upgrade_contract(base_address, new_class_hash);
+}
+
 #[test]
 #[available_gas(6000000)]
 #[should_panic(expected: ('must be called by world', 'ENTRYPOINT_FAILED'))]
@@ -62,3 +89,59 @@ fn test_upgrade_direct() {
     let upgradeable_dispatcher = IUpgradeableDispatcher { contract_address: base_address };
     upgradeable_dispatcher.upgrade(new_class_hash);
 }
+
+use debug::PrintTrait;
+
+#[starknet::interface]
+trait INameOnly<T> {
+    fn name(self: @T) -> felt252;
+}
+
+#[starknet::contract]
+mod invalid_model {
+    #[storage]
+    struct Storage {}
+
+    #[abi(embed_v0)]
+    impl InvalidModelName of super::INameOnly<ContractState> {
+        fn name(self: @ContractState) -> felt252 {
+            // Pre-computed address of a contract deployed through the world.
+            0x34534b116332dd9459bfde65280822d84c130e3f1faeb63af8455f83e733f4f
+        }
+    }
+}
+
+#[starknet::contract]
+mod invalid_model_world {
+    #[storage]
+    struct Storage {}
+
+    #[abi(embed_v0)]
+    impl InvalidModelName of super::INameOnly<ContractState> {
+        fn name(self: @ContractState) -> felt252 {
+            // World address is 0, and not registered as deployed through the world
+            // as it's itself.
+            0
+        }
+    }
+}
+
+#[test]
+#[available_gas(6000000)]
+#[should_panic(expected: ('invalid model name', 'ENTRYPOINT_FAILED',))]
+fn test_deploy_from_world_invalid_model() {
+    let world = deploy_world();
+
+    let base_address = world.deploy_contract(0, base::TEST_CLASS_HASH.try_into().unwrap());
+    base_address.print();
+
+    world.register_model(invalid_model::TEST_CLASS_HASH.try_into().unwrap());
+}
+
+#[test]
+#[available_gas(6000000)]
+#[should_panic(expected: ('invalid model name', 'ENTRYPOINT_FAILED',))]
+fn test_deploy_from_world_invalid_model_world() {
+    let world = deploy_world();
+    world.register_model(invalid_model_world::TEST_CLASS_HASH.try_into().unwrap());
+}