Display deploy hint command after sncast declare (#3771)

<!-- Reference any GitHub issues resolved by this PR -->

Closes #2758

## Introduced changes

`sncast declare` command now outputs a ready-to-use deployment command
after successful declaration.

## Checklist

<!-- Make sure all of these are complete -->

- [x] Linked relevant issue
- [x] Updated relevant documentation
- [x] Added relevant tests
- [x] Performed self-review of the code
- [x] Added changes to `CHANGELOG.md`

Author: franciszekjob

CHANGELOG.md

@@ -18,6 +18,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 #### Added
 
 - Debug logging for `sncast` commands that can be enabled by setting `CAST_LOG` env variable.
+- `sncast declare` command now outputs a ready-to-use deployment command after successful declaration.
 
 ## [0.50.0] - 2025-09-29
 

crates/sncast/src/helpers/rpc.rs

@@ -45,7 +45,7 @@ impl RpcArgs {
     }
 
     #[must_use]
-    fn get_url(&self, config_url: &String) -> Option<String> {
+    pub fn get_url(&self, config_url: &String) -> Option<String> {
         if let Some(network) = self.network {
             let free_provider = FreeProvider::semi_random();
             Some(network.url(&free_provider))
@@ -98,6 +98,17 @@ impl Network {
     }
 }
 
+#[must_use]
+pub fn generate_network_flag(rpc_url: Option<&str>, network: Option<&Network>) -> String {
+    if let Some(network) = network {
+        format!("--network {network}")
+    } else if let Some(rpc_url) = rpc_url {
+        format!("--url {rpc_url}")
+    } else {
+        unreachable!("Either `--rpc_url` or `--network` must be provided.")
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/sncast/src/main.rs

@@ -20,10 +20,11 @@ use sncast::helpers::config::{combine_cast_configs, get_global_config_path};
 use sncast::helpers::configuration::CastConfig;
 use sncast::helpers::constants::DEFAULT_ACCOUNTS_FILE;
 use sncast::helpers::output_format::output_format_from_json_flag;
+use sncast::helpers::rpc::generate_network_flag;
 use sncast::helpers::scarb_utils::{
     BuildConfig, assert_manifest_path_exists, build_and_load_artifacts, get_package_metadata,
 };
-use sncast::response::declare::DeclareResponse;
+use sncast::response::declare::{DeclareResponse, DeployCommandMessage};
 use sncast::response::errors::handle_starknet_command_error;
 use sncast::response::explorer_link::block_explorer_link_if_allowed;
 use sncast::response::transformed_call::transform_response;
@@ -32,7 +33,7 @@ use sncast::{
     get_contract_class,
 };
 use starknet::core::types::ContractClass;
-use starknet::core::types::contract::AbiEntry;
+use starknet::core::types::contract::{AbiEntry, SierraClass};
 use starknet::core::utils::get_selector_from_name;
 use starknet::providers::Provider;
 use starknet_commands::verify::Verify;
@@ -289,7 +290,7 @@ async fn run_async_command(cli: Cli, config: CastConfig, ui: &UI) -> Result<()>
             .expect("Failed to build contract");
 
             let result = starknet_commands::declare::declare(
-                declare,
+                &declare,
                 &account,
                 &artifacts,
                 wait_config,
@@ -309,8 +310,36 @@ async fn run_async_command(cli: Cli, config: CastConfig, ui: &UI) -> Result<()>
 
             let block_explorer_link =
                 block_explorer_link_if_allowed(&result, provider.chain_id().await?, &rpc, &config);
+
+            let deploy_command_message = if let Ok(response) = &result {
+                // TODO(#3785)
+                let contract_artifacts = artifacts
+                    .get(&declare.contract.clone())
+                    .expect("Failed to get contract artifacts");
+                let contract_definition: SierraClass =
+                    serde_json::from_str(&contract_artifacts.sierra)
+                        .context("Failed to parse sierra artifact")?;
+                let network_flag = generate_network_flag(
+                    rpc.get_url(&config.url).as_deref(),
+                    rpc.network.as_ref(),
+                );
+                Some(DeployCommandMessage::new(
+                    &contract_definition.abi,
+                    response,
+                    &config.account,
+                    &config.accounts_file,
+                    network_flag,
+                ))
+            } else {
+                None
+            };
+
             process_command_result("declare", result, ui, block_explorer_link);
 
+            if let Some(deploy_command_message) = deploy_command_message {
+                ui.println(&deploy_command_message?);
+            }
+
             Ok(())
         }
 

crates/sncast/src/response/declare.rs

@@ -1,6 +1,8 @@
 use super::{command::CommandResponse, explorer_link::OutputLink};
 use crate::helpers::block_explorer::LinkProvider;
 use crate::response::cast_message::SncastMessage;
+use anyhow::Error;
+use camino::Utf8PathBuf;
 use conversions::string::IntoHexStr;
 use conversions::{padded_felt::PaddedFelt, serde::serialize::CairoSerialize};
 use foundry_ui::Message;
@@ -9,6 +11,8 @@ use indoc::formatdoc;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use serde_json::json;
+use starknet::core::types::contract::{AbiConstructor, AbiEntry};
+use std::fmt::Write;
 #[derive(Clone, Serialize, Deserialize, CairoSerialize, Debug, PartialEq)]
 pub struct DeclareTransactionResponse {
     pub class_hash: PaddedFelt,
@@ -129,3 +133,118 @@ impl OutputLink for DeclareTransactionResponse {
         )
     }
 }
+
+#[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
+pub struct DeployCommandMessage {
+    accounts_file: Option<String>,
+    account: String,
+    class_hash: PaddedFelt,
+    arguments_flag: Option<String>,
+    network_flag: String,
+}
+
+impl DeployCommandMessage {
+    pub fn new(
+        abi: &[AbiEntry],
+        response: &DeclareTransactionResponse,
+        account: &str,
+        accounts_file: &Utf8PathBuf,
+        network_flag: String,
+    ) -> Result<Self, Error> {
+        let arguments_flag: Option<String> = generate_arguments_flag(abi);
+        let accounts_file_str = accounts_file.to_string();
+        let accounts_file = (!accounts_file_str
+            .contains("starknet_accounts/starknet_open_zeppelin_accounts.json"))
+        .then_some(accounts_file_str);
+
+        Ok(Self {
+            account: account.to_string(),
+            accounts_file,
+            class_hash: response.class_hash,
+            arguments_flag,
+            network_flag,
+        })
+    }
+}
+
+impl Message for DeployCommandMessage {
+    fn text(&self) -> String {
+        let mut command = String::from("sncast");
+
+        let accounts_file_flag = generate_accounts_file_flag(self.accounts_file.as_ref());
+        if let Some(flag) = accounts_file_flag {
+            write!(command, " {flag}").unwrap();
+        }
+
+        let account_flag = format!("--account {}", self.account);
+        write!(command, " {account_flag}").unwrap();
+
+        write!(command, " deploy").unwrap();
+
+        write!(
+            command,
+            " --class-hash {}",
+            self.class_hash.into_hex_string()
+        )
+        .unwrap();
+
+        if let Some(arguments) = &self.arguments_flag {
+            write!(command, " {arguments}").unwrap();
+        }
+
+        write!(command, " {}", self.network_flag).unwrap();
+
+        let header = if self.arguments_flag.is_some() {
+            "To deploy a contract of this class, replace the placeholders in `--arguments` with your actual values, then run:"
+        } else {
+            "To deploy a contract of this class, run:"
+        };
+
+        formatdoc!(
+            "
+            {header}
+            {command}
+            "
+        )
+    }
+
+    fn json(&self) -> Value {
+        // This message is only helpful in human mode, we don't need it in JSON mode.
+        Value::Null
+    }
+}
+
+fn generate_constructor_placeholder_arguments(constructor: AbiConstructor) -> String {
+    constructor
+        .inputs
+        .into_iter()
+        .map(|input| {
+            let input_type = input
+                .r#type
+                .split("::")
+                .last()
+                .expect("Failed to get last part of input type");
+            format!("<{}: {})>", input.name, input_type)
+        })
+        .collect::<Vec<String>>()
+        .join(", ")
+}
+
+fn generate_arguments_flag(abi: &[AbiEntry]) -> Option<String> {
+    let arguments = abi.iter().find_map(|entry| {
+        if let AbiEntry::Constructor(constructor) = entry {
+            let arguments = generate_constructor_placeholder_arguments(constructor.clone());
+            (!arguments.is_empty()).then_some(arguments)
+        } else {
+            None
+        }
+    });
+
+    arguments.map(|arguments| format!("--arguments '{arguments}'"))
+}
+
+fn generate_accounts_file_flag(accounts_file: Option<&String>) -> Option<String> {
+    accounts_file
+        .as_ref()
+        .map(|file| format!("--accounts-file {file}"))
+}

crates/sncast/src/starknet_commands/account/create.rs

@@ -15,7 +15,7 @@ use sncast::helpers::constants::{
     BRAAVOS_BASE_ACCOUNT_CLASS_HASH, BRAAVOS_CLASS_HASH, CREATE_KEYSTORE_PASSWORD_ENV_VAR,
     OZ_CLASS_HASH, READY_CLASS_HASH,
 };
-use sncast::helpers::rpc::RpcArgs;
+use sncast::helpers::rpc::{RpcArgs, generate_network_flag};
 use sncast::response::account::create::AccountCreateResponse;
 use sncast::{
     AccountType, Network, check_class_hash_exists, check_if_legacy_contract,
@@ -336,16 +336,6 @@ fn write_account_to_file(
     Ok(())
 }
 
-fn generate_network_flag(rpc_url: Option<&str>, network: Option<&Network>) -> String {
-    if let Some(rpc_url) = rpc_url {
-        format!("--url {rpc_url}")
-    } else if let Some(network) = network {
-        format!("--network {network}")
-    } else {
-        unreachable!("Either `--rpc_url` or `--network` must be provided.")
-    }
-}
-
 fn generate_deploy_command(
     accounts_file: &Utf8PathBuf,
     rpc_url: Option<&str>,

crates/sncast/src/starknet_commands/declare.rs

@@ -47,8 +47,9 @@ pub struct Declare {
     pub rpc: RpcArgs,
 }
 
+// TODO(#3785)
 pub async fn declare(
-    declare: Declare,
+    declare: &Declare,
     account: &SingleOwnerAccount<&JsonRpcClient<HttpTransport>, LocalWallet>,
     artifacts: &HashMap<String, StarknetContractArtifacts>,
     wait_config: WaitForTx,
@@ -70,7 +71,7 @@ pub async fn declare(
     declare_with_artifacts(
         contract_definition,
         casm_contract_definition,
-        declare.fee_args,
+        declare.fee_args.clone(),
         declare.nonce,
         account,
         wait_config,
@@ -81,7 +82,7 @@ pub async fn declare(
 }
 
 #[allow(clippy::too_many_arguments)]
-pub(crate) async fn declare_with_artifacts(
+pub async fn declare_with_artifacts(
     sierra_class: SierraClass,
     compiled_casm: CompiledClass,
     fee_args: FeeArgs,

crates/sncast/src/starknet_commands/script/run.rs

@@ -144,7 +144,7 @@ impl<'a> ExtensionLogic for CastScriptExtension<'a> {
                 }
 
                 let declare_result = self.tokio_runtime.block_on(declare::declare(
-                    declare,
+                    &declare,
                     self.account()?,
                     self.artifacts,
                     WaitForTx {

crates/sncast/tests/data/contracts/contract_with_constructor_params/Scarb.toml

@@ -0,0 +1,12 @@
+[package]
+name = "contract_with_constructor_params"
+version = "0.1.0"
+edition = "2024_07"
+
+[dependencies]
+starknet = ">=2.10.1"
+
+[[target.starknet-contract]]
+
+[lib]
+sierra = false

crates/sncast/tests/data/contracts/contract_with_constructor_params/src/lib.cairo

@@ -0,0 +1,10 @@
+#[starknet::contract]
+mod ContractWithConstructorParams {
+    #[storage]
+    struct Storage {}
+
+    #[constructor]
+    fn constructor(ref self: ContractState, foo: felt252, bar: felt252) {
+        let _x = foo + bar;
+    }
+}