feat(sozo): add invoke command that doesn't require the world context

Author: glihm

bin/sozo/src/commands/execute.rs

@@ -19,7 +19,7 @@ use super::options::world::WorldOptions;
 use crate::utils::{self, CALLDATA_DOC};
 
 #[derive(Debug, Args)]
-#[command(about = "Execute one or several systems with the given calldata.")]
+#[command(about = "Execute one or several systems in the world context with the given calldata.")]
 pub struct ExecuteArgs {
     #[arg(num_args = 1..)]
     #[arg(required = true)]

bin/sozo/src/commands/invoke.rs

@@ -0,0 +1,92 @@
+use anyhow::{Context, Result};
+use clap::Args;
+use dojo_utils::{Invoker, TxnConfig};
+use dojo_world::config::calldata_decoder;
+use sozo_ui::SozoUi;
+use starknet::core::types::{Call, Felt};
+use starknet::core::utils::get_selector_from_name;
+use tracing::trace;
+
+use super::options::account::AccountOptions;
+use super::options::starknet::StarknetOptions;
+use super::options::transaction::TransactionOptions;
+use crate::utils::{get_account_from_env, CALLDATA_DOC};
+
+#[derive(Debug, Args)]
+#[command(about = "Invoke a contract entrypoint on Starknet. This command does not require the \
+                   world context to be loaded. Use the execute command to execute systems in the \
+                   world context.")]
+pub struct InvokeArgs {
+    #[arg(value_name = "CONTRACT_ADDRESS", help = "Target contract address.")]
+    pub contract: Felt,
+
+    #[arg(value_name = "ENTRYPOINT", help = "Entrypoint to invoke on the contract.")]
+    pub entrypoint: String,
+
+    #[arg(
+        value_name = "ARG",
+        num_args = 0..,
+        help = format!(
+            "Calldata elements for the entrypoint (space separated).\n\n{}",
+            CALLDATA_DOC
+        )
+    )]
+    pub calldata: Vec<String>,
+
+    #[command(flatten)]
+    pub transaction: TransactionOptions,
+
+    #[command(flatten)]
+    pub starknet: StarknetOptions,
+
+    #[command(flatten)]
+    pub account: AccountOptions,
+}
+
+impl InvokeArgs {
+    pub async fn run(self, ui: &SozoUi) -> Result<()> {
+        trace!(args = ?self);
+
+        let InvokeArgs { contract, entrypoint, calldata, transaction, starknet, account } = self;
+
+        let account = get_account_from_env(account, &starknet).await?;
+        let txn_config: TxnConfig = transaction.try_into()?;
+
+        ui.title(format!("Invoke contract {:#066x}", contract));
+        ui.step(format!("Entrypoint: {}", entrypoint));
+
+        let mut decoded = Vec::new();
+        for item in calldata {
+            let felt_values = calldata_decoder::decode_single_calldata(&item)
+                .with_context(|| format!("Failed to parse calldata argument `{item}`"))?;
+            decoded.extend(felt_values);
+        }
+
+        if decoded.is_empty() {
+            ui.verbose("Calldata: <empty>");
+        } else {
+            ui.verbose(format!("Calldata ({} felt(s))", decoded.len()));
+        }
+
+        let selector = get_selector_from_name(&entrypoint)?;
+        let call = Call { to: contract, selector, calldata: decoded };
+
+        let invoker = Invoker::new(account, txn_config);
+        let result = invoker.invoke(call).await?;
+
+        match result {
+            dojo_utils::TransactionResult::Noop => {
+                ui.result("Nothing to invoke (noop).");
+            }
+            dojo_utils::TransactionResult::Hash(hash) => {
+                ui.result(format!("Invocation sent.\n  Tx hash   : {hash:#066x}"));
+            }
+            dojo_utils::TransactionResult::HashReceipt(hash, receipt) => {
+                ui.result(format!("Invocation included on-chain.\n  Tx hash   : {hash:#066x}"));
+                ui.debug(format!("Receipt: {:?}", receipt));
+            }
+        }
+
+        Ok(())
+    }
+}

bin/sozo/src/commands/mod.rs

@@ -18,6 +18,7 @@ pub(crate) mod execute;
 pub(crate) mod hash;
 pub(crate) mod init;
 pub(crate) mod inspect;
+pub(crate) mod invoke;
 pub(crate) mod mcp;
 pub(crate) mod migrate;
 pub(crate) mod model;
@@ -37,6 +38,7 @@ use execute::ExecuteArgs;
 use hash::HashArgs;
 use init::InitArgs;
 use inspect::InspectArgs;
+use invoke::InvokeArgs;
 use mcp::McpArgs;
 use migrate::MigrateArgs;
 use model::ModelArgs;
@@ -59,6 +61,8 @@ pub enum Commands {
     Events(Box<EventsArgs>),
     #[command(about = "Execute one or several systems with the given calldata.")]
     Execute(Box<ExecuteArgs>),
+    #[command(about = "Invoke a contract entrypoint on Starknet.")]
+    Invoke(Box<InvokeArgs>),
     #[command(about = "Clean the build directory")]
     Clean(Box<CleanArgs>),
     #[command(about = "Computes hash with different hash functions")]
@@ -98,6 +102,7 @@ impl fmt::Display for Commands {
             Commands::Events(_) => write!(f, "Events"),
             Commands::Execute(_) => write!(f, "Execute"),
             Commands::Hash(_) => write!(f, "Hash"),
+            Commands::Invoke(_) => write!(f, "Invoke"),
             Commands::Declare(_) => write!(f, "Declare"),
             Commands::Deploy(_) => write!(f, "Deploy"),
             Commands::Init(_) => write!(f, "Init"),
@@ -126,6 +131,7 @@ pub async fn run(command: Commands, scarb_metadata: &Metadata, ui: &SozoUi) -> R
         Commands::Clean(args) => args.run(scarb_metadata),
         Commands::Events(args) => args.run(scarb_metadata, ui).await,
         Commands::Execute(args) => args.run(scarb_metadata, ui).await,
+        Commands::Invoke(args) => args.run(ui).await,
         Commands::Hash(args) => args.run(scarb_metadata),
         Commands::Declare(args) => args.run(ui).await,
         Commands::Deploy(args) => args.run(ui).await,

bin/sozo/src/main.rs

@@ -47,6 +47,8 @@ async fn cli_main(args: SozoArgs, ui: &SozoUi) -> Result<()> {
         args.run(ui).await
     } else if let Commands::Deploy(args) = args.command {
         args.run(ui).await
+    } else if let Commands::Invoke(args) = args.command {
+        args.run(ui).await
     } else {
         // Default to the current directory to mimic how Scarb works.
         let manifest_path = if let Some(manifest_path) = &args.manifest_path {