fix(sozo): model get not using prefixes

bin/sozo/src/commands/mod.rs

@@ -5,7 +5,6 @@ use auth::AuthArgs;
 use clap::Subcommand;
 use events::EventsArgs;
 use scarb::core::{Config, Package, Workspace};
-use semver::{Version, VersionReq};
 use tracing::info_span;
 
 pub(crate) mod auth;
@@ -33,8 +32,6 @@ use init::InitArgs;
 use inspect::InspectArgs;
 use migrate::MigrateArgs;
 use model::ModelArgs;
-#[cfg(feature = "walnut")]
-use sozo_walnut::walnut::WalnutArgs;
 use test::TestArgs;
 
 pub(crate) const LOG_TARGET: &str = "sozo::cli";
@@ -50,7 +47,7 @@ pub enum Commands {
     #[command(about = "Run a migration, declaring and deploying contracts as necessary to update \
                        the world")]
     Migrate(Box<MigrateArgs>),
-    #[command(about = "Execute one or several systems with the given calldata.")]
+    #[command(about = "Execute a system with the given calldata.")]
     Execute(Box<ExecuteArgs>),
     #[command(about = "Inspect the world")]
     Inspect(Box<InspectArgs>),
@@ -68,9 +65,6 @@ pub enum Commands {
     Model(Box<ModelArgs>),
     #[command(about = "Inspect events emitted by the world")]
     Events(Box<EventsArgs>),
-    #[cfg(feature = "walnut")]
-    #[command(about = "Interact with walnut.dev - transactions debugger and simulator")]
-    Walnut(Box<WalnutArgs>),
 }
 
 impl fmt::Display for Commands {
@@ -89,8 +83,6 @@ impl fmt::Display for Commands {
             Commands::Init(_) => write!(f, "Init"),
             Commands::Model(_) => write!(f, "Model"),
             Commands::Events(_) => write!(f, "Events"),
-            #[cfg(feature = "walnut")]
-            Commands::Walnut(_) => write!(f, "WalnutVerify"),
         }
     }
 }
@@ -113,12 +105,10 @@ pub fn run(command: Commands, config: &Config) -> Result<()> {
         Commands::Clean(args) => args.run(config),
         Commands::Call(args) => args.run(config),
         Commands::Test(args) => args.run(config),
-        Commands::Hash(args) => args.run(config).map(|_| ()),
+        Commands::Hash(args) => args.run().map(|_| ()),
         Commands::Init(args) => args.run(config),
         Commands::Model(args) => args.run(config),
         Commands::Events(args) => args.run(config),
-        #[cfg(feature = "walnut")]
-        Commands::Walnut(args) => args.run(config),
     }
 }
 
@@ -139,43 +129,24 @@ pub fn check_package_dojo_version(ws: &Workspace<'_>, package: &Package) -> anyh
             && dojo_dep_str.contains("tag=v")
             && !dojo_dep_str.contains(dojo_version)
         {
-            // safe to unwrap since we know the string contains "tag=v".
-            // "dojo * (git+https://github.com/dojoengine/dojo?tag=v1.0.10)"
-            let dojo_dep_version = dojo_dep_str.split("tag=v")
-            .nth(1)  // Get the part after "tag=v"
-            .map(|s| s.trim_end_matches(')'))
-            .expect("Unexpected dojo dependency format");
-
-            let dojo_dep_version = Version::parse(dojo_dep_version).unwrap();
-
-            let version_parts: Vec<&str> = dojo_version.split('.').collect();
-            let major_minor = format!("{}.{}", version_parts[0], version_parts[1]);
-            let dojo_req_version = VersionReq::parse(&format!(">={}", major_minor)).unwrap();
-
-            if !dojo_req_version.matches(&dojo_dep_version) {
-                if let Ok(cp) = ws.current_package() {
-                    // Selected package.
-                    let path = if cp.id == package.id {
-                        package.manifest_path()
-                    } else {
-                        ws.manifest_path()
-                    };
-
-                    anyhow::bail!(
-                        "Found dojo-core version mismatch: expected {}. Please verify your dojo \
-                         dependency in {}",
-                        dojo_req_version,
-                        path
-                    )
-                } else {
-                    // Virtual workspace.
-                    anyhow::bail!(
-                        "Found dojo-core version mismatch: expected {}. Please verify your dojo \
-                         dependency in {}",
-                        dojo_req_version,
-                        ws.manifest_path()
-                    )
-                }
+            if let Ok(cp) = ws.current_package() {
+                let path =
+                    if cp.id == package.id { package.manifest_path() } else { ws.manifest_path() };
+
+                anyhow::bail!(
+                    "Found dojo-core version mismatch: expected {}. Please verify your dojo \
+                     dependency in {}",
+                    dojo_version,
+                    path
+                )
+            } else {
+                // Virtual workspace.
+                anyhow::bail!(
+                    "Found dojo-core version mismatch: expected {}. Please verify your dojo \
+                     dependency in {}",
+                    dojo_version,
+                    ws.manifest_path()
+                )
             }
         }
     }

bin/sozo/src/commands/model.rs

@@ -1,5 +1,6 @@
 use anyhow::Result;
 use clap::{Args, Subcommand};
+use dojo_world::config::calldata_decoder;
 use scarb::core::Config;
 use sozo_ops::model;
 use sozo_ops::resource_descriptor::ResourceDescriptor;
@@ -109,7 +110,9 @@ hashes, called 'hash' in the following documentation.
 
         #[arg(value_name = "KEYS")]
         #[arg(value_delimiter = ',')]
-        #[arg(help = "Comma seperated values e.g., 0x12345,0x69420,...")]
+        #[arg(help = "Comma separated values e.g., 0x12345,0x69420,sstr:\"hello\". Supported \
+                      prefixes:\n  - sstr: A cairo short string\n  - no prefix: A cairo felt")]
+        #[arg(value_parser = model_key_parser)]
         keys: Vec<Felt>,
 
         #[command(flatten)]
@@ -124,6 +127,18 @@ hashes, called 'hash' in the following documentation.
     },
 }
 
+// Custom parser for model keys
+fn model_key_parser(s: &str) -> Result<Felt> {
+    if s.contains(':') && !s.starts_with("sstr:") {
+        anyhow::bail!("Only 'sstr:' prefix is supported for model keys");
+    }
+    let felts = calldata_decoder::decode_calldata(s)?;
+    if felts.is_empty() {
+        anyhow::bail!("Failed to parse key '{}': no values returned.", s);
+    }
+    Ok(felts[0])
+}
+
 impl ModelArgs {
     pub fn run(self, config: &Config) -> Result<()> {
         trace!(args = ?self);
@@ -222,3 +237,67 @@ impl ModelArgs {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use clap::Parser;
+    use starknet::core::utils::cairo_short_string_to_felt;
+
+    use super::*;
+
+    #[derive(Parser, Debug)]
+    struct TestCommand {
+        #[command(subcommand)]
+        command: ModelCommand,
+    }
+
+    #[test]
+    fn test_model_get_argument_parsing() {
+        // Test parsing with hex
+        let args = TestCommand::parse_from([
+            "model",
+            "get",
+            "Account",
+            "0x054cb935d86d80b5a0a6e756edf448ab33876d01dd2b07a2a4e63a41e06d0ef5,0x6d69737479",
+        ]);
+
+        if let ModelCommand::Get { keys, .. } = args.command {
+            let expected = vec![
+                Felt::from_hex(
+                    "0x054cb935d86d80b5a0a6e756edf448ab33876d01dd2b07a2a4e63a41e06d0ef5",
+                )
+                .unwrap(),
+                Felt::from_hex("0x6d69737479").unwrap(),
+            ];
+            assert_eq!(keys, expected);
+        } else {
+            panic!("Expected Get command");
+        }
+
+        // Test parsing with string prefix
+        let args = TestCommand::parse_from([
+            "model",
+            "get",
+            "Account",
+            "0x054cb935d86d80b5a0a6e756edf448ab33876d01dd2b07a2a4e63a41e06d0ef5,sstr:\"misty\"",
+        ]);
+
+        if let ModelCommand::Get { keys, .. } = args.command {
+            let expected = vec![
+                Felt::from_hex(
+                    "0x054cb935d86d80b5a0a6e756edf448ab33876d01dd2b07a2a4e63a41e06d0ef5",
+                )
+                .unwrap(),
+                cairo_short_string_to_felt("misty").unwrap(),
+            ];
+            assert_eq!(keys, expected);
+        } else {
+            panic!("Expected Get command");
+        }
+
+        // Test invalid prefix
+        let result =
+            TestCommand::try_parse_from(["model", "get", "Account", "0x123,str:\"hello\""]);
+        assert!(result.is_err());
+    }
+}

crates/dojo/world/src/config/calldata_decoder.rs

@@ -161,7 +161,14 @@ pub fn decode_single_calldata(item: &str) -> DecoderResult<Vec<Felt>> {
         match prefix {
             "u256" => U256CalldataDecoder.decode(value)?,
             "str" => StrCalldataDecoder.decode(value)?,
-            "sstr" => ShortStrCalldataDecoder.decode(value)?,
+            "sstr" => {
+                let value = if value.starts_with('"') && value.ends_with('"') {
+                    value.trim_matches('"')
+                } else {
+                    value
+                };
+                ShortStrCalldataDecoder.decode(value)?
+            }
             "int" => SignedIntegerCalldataDecoder.decode(value)?,
             _ => DefaultCalldataDecoder.decode(item)?,
         }