Support grant/revoke writer/owner

bin/sozo/Cargo.toml

@@ -28,6 +28,7 @@ dojo-bindgen.workspace = true
 dojo-lang.workspace = true
 dojo-types.workspace = true
 dojo-world = { workspace = true, features = [ "contracts", "metadata", "migration" ] }
+futures.workspace = true
 notify = "6.0.1"
 notify-debouncer-mini = "0.3.0"
 scarb-ui.workspace = true

bin/sozo/src/commands/auth.rs

@@ -1,7 +1,11 @@
+use std::str::FromStr;
+
 use anyhow::Result;
 use clap::{Args, Subcommand};
+use dojo_world::contracts::cairo_utils;
 use dojo_world::metadata::dojo_metadata_from_workspace;
 use scarb::core::Config;
+use starknet_crypto::FieldElement;
 
 use super::options::account::AccountOptions;
 use super::options::starknet::StarknetOptions;
@@ -15,17 +19,131 @@ pub struct AuthArgs {
     pub command: AuthCommand,
 }
 
+#[derive(Debug, Clone)]
+pub struct ModelContract {
+    pub model: FieldElement,
+    pub contract: FieldElement,
+}
+
+impl FromStr for ModelContract {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let parts: Vec<&str> = s.split(',').collect();
+
+        let (model, contract_part) = match parts.as_slice() {
+            [model, contract] => (model.to_string(), *contract),
+            _ => anyhow::bail!(
+                "Model and contract address are expected to be comma separated: `sozo auth writer \
+                 model_name,0x1234`"
+            ),
+        };
+
+        let model = cairo_utils::str_to_felt(&model)
+            .map_err(|_| anyhow::anyhow!("Invalid model name: {}", model))?;
+
+        let contract = FieldElement::from_hex_be(contract_part)
+            .map_err(|_| anyhow::anyhow!("Invalid contract address: {}", contract_part))?;
+
+        Ok(ModelContract { model, contract })
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum ResourceType {
+    Contract(String),
+    Model(FieldElement),
+}
+
+#[derive(Debug, Clone)]
+pub struct OwnerResource {
+    pub owner: FieldElement,
+    pub resource: ResourceType,
+}
+
+impl FromStr for OwnerResource {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let parts: Vec<&str> = s.split(',').collect();
+
+        let (owner_part, resource_part) = match parts.as_slice() {
+            [owner, resource] => (*owner, *resource),
+            _ => anyhow::bail!(
+                "Owner and resource are expected to be comma separated: `sozo auth owner \
+                 0x1234,resource_type:resource_name`"
+            ),
+        };
+
+        let owner = FieldElement::from_hex_be(owner_part)
+            .map_err(|_| anyhow::anyhow!("Invalid owner address: {}", owner_part))?;
+
+        let resource_parts: Vec<&str> = resource_part.split(':').collect();
+        let resource = match resource_parts.as_slice() {
+            ["contract", name] => ResourceType::Contract(name.to_string()),
+            ["model", name] => {
+                let model = cairo_utils::str_to_felt(name)
+                    .map_err(|_| anyhow::anyhow!("Invalid model name: {}", name))?;
+                ResourceType::Model(model)
+            }
+            _ => anyhow::bail!(
+                "Resource is expected to be in the format `resource_type:resource_name`: `sozo \
+                 auth owner 0x1234,resource_type:resource_name`"
+            ),
+        };
+
+        Ok(OwnerResource { owner, resource })
+    }
+}
+
 #[derive(Debug, Subcommand)]
-pub enum AuthCommand {
-    #[command(about = "Auth a system with the given calldata.")]
+pub enum AuthKind {
+    #[command(about = "Grant a contract permission to write to a model.")]
     Writer {
         #[arg(num_args = 1..)]
         #[arg(required = true)]
         #[arg(value_name = "model,contract_address")]
         #[arg(help = "A list of models and contract address to grant write access to. Comma \
                       separated values to indicate model name and contract address e.g. \
                       model_name,0x1234 model_name,0x1111 ")]
-        models_contracts: Vec<String>,
+        models_contracts: Vec<ModelContract>,
+    },
+    #[command(about = "Grant ownership of a resource.")]
+    Owner {
+        #[arg(num_args = 1..)]
+        #[arg(required = true)]
+        #[arg(value_name = "owner,resource")]
+        #[arg(help = "A list of owners and resources to grant ownership to. Comma separated \
+                      values to indicate owner address and resouce e.g. \
+                      0x1234,contract:contract_name 0x1111,contract:contract_address, \
+                      0xbeef,model:model_name")]
+        owners_resources: Vec<OwnerResource>,
+    },
+}
+
+#[derive(Debug, Subcommand)]
+pub enum AuthCommand {
+    #[command(about = "Grant an auth role.")]
+    Grant {
+        #[command(subcommand)]
+        kind: AuthKind,
+
+        #[command(flatten)]
+        world: WorldOptions,
+
+        #[command(flatten)]
+        starknet: StarknetOptions,
+
+        #[command(flatten)]
+        account: AccountOptions,
+
+        #[command(flatten)]
+        transaction: TransactionOptions,
+    },
+    #[command(about = "Revoke an auth role.")]
+    Revoke {
+        #[command(subcommand)]
+        kind: AuthKind,
 
         #[command(flatten)]
         world: WorldOptions,

bin/sozo/src/commands/execute.rs

@@ -7,6 +7,7 @@ use starknet::core::types::FieldElement;
 use super::options::account::AccountOptions;
 use super::options::starknet::StarknetOptions;
 use super::options::transaction::TransactionOptions;
+use super::options::world::WorldOptions;
 use crate::ops::execute;
 
 #[derive(Debug, Args)]
@@ -31,6 +32,9 @@ pub struct ExecuteArgs {
     #[command(flatten)]
     pub account: AccountOptions,
 
+    #[command(flatten)]
+    pub world: WorldOptions,
+
     #[command(flatten)]
     pub transaction: TransactionOptions,
 }

bin/sozo/src/ops/auth.rs

@@ -1,57 +1,75 @@
 use anyhow::{Context, Result};
-use dojo_world::contracts::cairo_utils;
 use dojo_world::contracts::world::WorldContract;
 use dojo_world::metadata::Environment;
 use dojo_world::utils::TransactionWaiter;
 use starknet::accounts::Account;
-use starknet::core::types::FieldElement;
 
-use crate::commands::auth::AuthCommand;
+use super::get_contract_address;
+use crate::commands::auth::{AuthCommand, AuthKind, ResourceType};
 
 pub async fn execute(command: AuthCommand, env_metadata: Option<Environment>) -> Result<()> {
     match command {
-        AuthCommand::Writer { models_contracts, world, starknet, account, transaction } => {
-            let world_address = world.address(env_metadata.as_ref())?;
-            let provider = starknet.provider(env_metadata.as_ref())?;
+        AuthCommand::Grant { kind, world, starknet, account, transaction } => match kind {
+            AuthKind::Writer { models_contracts } => {
+                let world_address = world.address(env_metadata.as_ref())?;
+                let provider = starknet.provider(env_metadata.as_ref())?;
 
-            let account = account.account(&provider, env_metadata.as_ref()).await?;
-            let world = WorldContract::new(world_address, &account);
+                let account = account.account(&provider, env_metadata.as_ref()).await?;
+                let world = WorldContract::new(world_address, &account);
 
-            let mut calls = vec![];
+                let calls = models_contracts
+                    .iter()
+                    .map(|mc| world.grant_writer_getcall(&mc.model, &mc.contract.into()))
+                    .collect();
 
-            for mc in models_contracts {
-                let parts: Vec<&str> = mc.split(',').collect();
+                let res = account
+                    .execute(calls)
+                    .send()
+                    .await
+                    .with_context(|| "Failed to send transaction")?;
 
-                let (model, contract_part) = match parts.as_slice() {
-                    [model, contract] => (model.to_string(), *contract),
-                    _ => anyhow::bail!(
-                        "Model and contract address are expected to be comma separated: `sozo \
-                         auth writer model_name,0x1234`"
-                    ),
-                };
+                if transaction.wait {
+                    let receipt = TransactionWaiter::new(res.transaction_hash, &provider).await?;
+                    println!("{}", serde_json::to_string_pretty(&receipt)?);
+                } else {
+                    println!("Transaction hash: {:#x}", res.transaction_hash);
+                }
+            }
+            AuthKind::Owner { owners_resources } => {
+                let world_address = world.address(env_metadata.as_ref())?;
+                let provider = starknet.provider(env_metadata.as_ref())?;
 
-                let contract = FieldElement::from_hex_be(contract_part)
-                    .map_err(|_| anyhow::anyhow!("Invalid contract address: {}", contract_part))?;
+                let account = account.account(&provider, env_metadata.as_ref()).await?;
+                let world = WorldContract::new(world_address, &account);
 
-                calls.push(
-                    world
-                        .grant_writer_getcall(&cairo_utils::str_to_felt(&model)?, &contract.into()),
-                );
-            }
+                let mut calls = Vec::new();
+
+                for or in owners_resources {
+                    let resource = match &or.resource {
+                        ResourceType::Model(name) => *name,
+                        ResourceType::Contract(name_or_address) => {
+                            get_contract_address(&world, name_or_address.clone()).await?
+                        }
+                    };
+
+                    calls.push(world.grant_owner_getcall(&or.owner.into(), &resource));
+                }
+
+                let res = account
+                    .execute(calls)
+                    .send()
+                    .await
+                    .with_context(|| "Failed to send transaction")?;
 
-            let res = account
-                .execute(calls)
-                .send()
-                .await
-                .with_context(|| "Failed to send transaction")?;
-
-            if transaction.wait {
-                let receipt = TransactionWaiter::new(res.transaction_hash, &provider).await?;
-                println!("{}", serde_json::to_string_pretty(&receipt)?);
-            } else {
-                println!("Transaction hash: {:#x}", res.transaction_hash);
+                if transaction.wait {
+                    let receipt = TransactionWaiter::new(res.transaction_hash, &provider).await?;
+                    println!("{}", serde_json::to_string_pretty(&receipt)?);
+                } else {
+                    println!("Transaction hash: {:#x}", res.transaction_hash);
+                }
             }
-        }
+        },
+        _ => todo!(),
     }
 
     Ok(())

bin/sozo/src/ops/execute.rs

@@ -1,50 +1,24 @@
 use anyhow::{Context, Result};
+use dojo_world::contracts::world::WorldContract;
 use dojo_world::metadata::Environment;
-use dojo_world::migration::strategy::generate_salt;
 use dojo_world::utils::TransactionWaiter;
 use starknet::accounts::{Account, Call};
-use starknet::core::types::{BlockId, BlockTag, FieldElement, FunctionCall};
-use starknet::core::utils::{get_contract_address, get_selector_from_name};
-use starknet::macros::selector;
-use starknet::providers::Provider;
+use starknet::core::utils::get_selector_from_name;
 
+use super::get_contract_address;
 use crate::commands::execute::ExecuteArgs;
 
 pub async fn execute(args: ExecuteArgs, env_metadata: Option<Environment>) -> Result<()> {
-    let ExecuteArgs { contract, entrypoint, calldata, starknet, account, transaction } = args;
+    let ExecuteArgs { contract, entrypoint, calldata, starknet, world, account, transaction } =
+        args;
 
     let provider = starknet.provider(env_metadata.as_ref())?;
 
-    let contract_address = if contract.starts_with("0x") {
-        FieldElement::from_hex_be(&contract)?
-    } else {
-        let world_address = env_metadata
-            .as_ref()
-            .and_then(|env| env.world_address.as_ref())
-            .cloned()
-            .ok_or_else(|| anyhow::anyhow!("No World Address found"))?;
-
-        let contract_class_hash = provider
-            .call(
-                FunctionCall {
-                    contract_address: FieldElement::from_hex_be(&world_address).unwrap(),
-                    entry_point_selector: selector!("base"),
-                    calldata: [].to_vec(),
-                },
-                BlockId::Tag(BlockTag::Latest),
-            )
-            .await?;
-
-        get_contract_address(
-            generate_salt(&contract),
-            contract_class_hash[0],
-            &[],
-            FieldElement::from_hex_be(&world_address).unwrap(),
-        )
-    };
-
     let account = account.account(&provider, env_metadata.as_ref()).await?;
+    let world_address = world.address(env_metadata.as_ref())?;
+    let world = WorldContract::new(world_address, &account);
 
+    let contract_address = get_contract_address(&world, contract).await?;
     let res = account
         .execute(vec![Call {
             calldata,

bin/sozo/src/ops/mod.rs

@@ -1,6 +1,29 @@
+use anyhow::Result;
+use dojo_world::contracts::world::WorldContract;
+use dojo_world::migration::strategy::generate_salt;
+use starknet::accounts::ConnectedAccount;
+use starknet::core::types::FieldElement;
+
 pub mod auth;
 pub mod events;
 pub mod execute;
 pub mod migration;
 pub mod model;
 pub mod register;
+
+pub async fn get_contract_address<A: ConnectedAccount + Sync>(
+    world: &WorldContract<A>,
+    name_or_address: String,
+) -> Result<FieldElement> {
+    if name_or_address.starts_with("0x") {
+        FieldElement::from_hex_be(&name_or_address).map_err(anyhow::Error::from)
+    } else {
+        let contract_class_hash = world.base().call().await?;
+        Ok(starknet::core::utils::get_contract_address(
+            generate_salt(&name_or_address),
+            contract_class_hash.into(),
+            &[],
+            world.address,
+        ))
+    }
+}