Allow declaring with deployment

cptartur · cptartur · commit 48c85d9003ed · 2025-10-03T16:23:16.000+02:00
commit-id:82e786a7

# Conflicts:
#	crates/sncast/src/main.rs
diff --git a/crates/sncast/src/helpers/block_explorer.rs b/crates/sncast/src/helpers/block_explorer.rs
@@ -129,6 +129,7 @@ impl LinkProvider for OkLink {
 
 #[cfg(test)]
 mod tests {
+    use crate::response::deploy::DeployResponseKind;
     use crate::{
         Network,
         helpers::block_explorer::Service,
@@ -139,23 +140,23 @@ mod tests {
     use starknet::macros::felt;
     use test_case::test_case;
 
-    const MAINNET_RESPONSE: DeployResponse = DeployResponse {
+    const MAINNET_RESPONSE: DeployResponseKind = DeployResponseKind::Deploy(DeployResponse {
         contract_address: PaddedFelt(felt!(
             "0x03241d40a2af53a34274dd411e090ccac1ea80e0380a0303fe76d71b046cfecb"
         )),
         transaction_hash: PaddedFelt(felt!(
             "0x7605291e593e0c6ad85681d09e27a601befb85033bdf1805aabf5d84617cf68"
         )),
-    };
+    });
 
-    const SEPOLIA_RESPONSE: DeployResponse = DeployResponse {
+    const SEPOLIA_RESPONSE: DeployResponseKind = DeployResponseKind::Deploy(DeployResponse {
         contract_address: PaddedFelt(felt!(
             "0x0716b5f1e3bd760c489272fd6530462a09578109049e26e3f4c70492676eae17"
         )),
         transaction_hash: PaddedFelt(felt!(
             "0x1cde70aae10f79d2d1289c923a1eeca7b81a2a6691c32551ec540fa2cb29c33"
         )),
-    };
+    });
 
     async fn assert_valid_links(input: &str) {
         let pattern = Regex::new(r"transaction: |contract: |class: ").unwrap();
@@ -175,7 +176,7 @@ mod tests {
     #[tokio::test]
     #[test_case(Network::Mainnet, &MAINNET_RESPONSE; "mainnet")]
     #[test_case(Network::Sepolia, &SEPOLIA_RESPONSE; "sepolia")]
-    async fn test_happy_case_starkscan(network: Network, response: &DeployResponse) {
+    async fn test_happy_case_starkscan(network: Network, response: &DeployResponseKind) {
         let provider = Service::Voyager.as_provider(network).unwrap();
         let result = response.format_links(provider);
         assert_valid_links(&result).await;
@@ -184,7 +185,7 @@ mod tests {
     #[tokio::test]
     #[test_case(Network::Mainnet, &MAINNET_RESPONSE; "mainnet")]
     #[test_case(Network::Sepolia, &SEPOLIA_RESPONSE; "sepolia")]
-    async fn test_happy_case_voyager(network: Network, response: &DeployResponse) {
+    async fn test_happy_case_voyager(network: Network, response: &DeployResponseKind) {
         let provider = Service::Voyager.as_provider(network).unwrap();
         let result = response.format_links(provider);
         assert_valid_links(&result).await;
diff --git a/crates/sncast/src/main.rs b/crates/sncast/src/main.rs
@@ -1,3 +1,4 @@
+use crate::starknet_commands::declare::declare;
 use crate::starknet_commands::declare_from::DeclareFrom;
 use crate::starknet_commands::deploy::DeployArguments;
 use crate::starknet_commands::multicall;
@@ -11,6 +12,7 @@ use anyhow::{Context, Result, bail};
 use camino::Utf8PathBuf;
 use clap::{CommandFactory, Parser, Subcommand};
 use configuration::load_config;
+use conversions::IntoConv;
 use data_transformer::transform;
 use foundry_ui::components::warning::WarningMessage;
 use foundry_ui::{Message, UI};
@@ -23,7 +25,10 @@ use sncast::helpers::output_format::output_format_from_json_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::{
+    AlreadyDeclaredResponse, DeclareResponse, DeclareTransactionResponse,
+};
+use sncast::response::deploy::{DeployResponseKind, DeployResponseWithDeclare};
 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;
@@ -361,9 +366,11 @@ async fn run_async_command(cli: Cli, config: CastConfig, ui: &UI) -> Result<()>
 
         Commands::Deploy(deploy) => {
             let Deploy {
+                identifier,
                 arguments,
                 fee_args,
                 rpc,
+                mut nonce,
                 ..
             } = deploy;
 
@@ -377,28 +384,97 @@ async fn run_async_command(cli: Cli, config: CastConfig, ui: &UI) -> Result<()>
             )
             .await?;
 
+            let (class_hash, declare_response) = if let Some(class_hash) = identifier.class_hash {
+                (class_hash, None)
+            } else if let Some(contract_name) = identifier.contract_name {
+                let manifest_path = assert_manifest_path_exists()?;
+                let package_metadata = get_package_metadata(&manifest_path, &None)?;
+                let artifacts = build_and_load_artifacts(
+                    &package_metadata,
+                    &BuildConfig {
+                        scarb_toml_path: manifest_path,
+                        json: cli.json,
+                        profile: cli.profile.unwrap_or("release".to_string()),
+                    },
+                    false,
+                    ui,
+                )
+                .expect("Failed to build contract");
+
+                let declare_result = declare(
+                    contract_name,
+                    fee_args.clone(),
+                    nonce,
+                    &account,
+                    &artifacts,
+                    WaitForTx {
+                        wait: true,
+                        wait_params: wait_config.wait_params,
+                        silent: true,
+                    },
+                    true,
+                    ui,
+                )
+                .await
+                .map_err(handle_starknet_command_error);
+
+                // Increment nonce after successful declare if it was explicitly provided
+                nonce = nonce.map(|n| n + Felt::ONE);
+
+                match declare_result {
+                    Ok(DeclareResponse::AlreadyDeclared(AlreadyDeclaredResponse {
+                        class_hash,
+                    })) => (class_hash.into_(), None),
+                    Ok(DeclareResponse::Success(declare_transaction_response)) => (
+                        declare_transaction_response.class_hash.into_(),
+                        Some(declare_transaction_response),
+                    ),
+                    Err(err) => {
+                        process_command_result::<DeclareTransactionResponse>(
+                            "deploy",
+                            Err(err),
+                            ui,
+                            None,
+                        );
+                        return Ok(());
+                    }
+                }
+            } else {
+                unreachable!("One of class_hash or contract_name must be provided");
+            };
+
             // safe to unwrap because "constructor" is a standardized name
             let selector = get_selector_from_name("constructor").unwrap();
 
-            let contract_class = get_contract_class(deploy.class_hash, &provider).await?;
+            let contract_class = get_contract_class(class_hash, &provider).await?;
 
             let arguments: Arguments = arguments.into();
             let calldata = arguments.try_into_calldata(contract_class, &selector)?;
 
             let result = starknet_commands::deploy::deploy(
-                deploy.class_hash,
+                class_hash,
                 &calldata,
                 deploy.salt,
                 deploy.unique,
                 fee_args,
-                deploy.nonce,
+                nonce,
                 &account,
                 wait_config,
                 ui,
             )
             .await
             .map_err(handle_starknet_command_error);
 
+            let result = if let Some(declare_response) = declare_response {
+                result.map(|r| {
+                    DeployResponseKind::DeployWithDeclare(
+                        DeployResponseWithDeclare::from_responses(&r, &declare_response),
+                    )
+                })
+            } else {
+                result.map(DeployResponseKind::Deploy)
+            };
+
             let block_explorer_link =
                 block_explorer_link_if_allowed(&result, provider.chain_id().await?, &rpc, &config);
             process_command_result("deploy", result, ui, block_explorer_link);
diff --git a/crates/sncast/src/response/deploy.rs b/crates/sncast/src/response/deploy.rs
@@ -1,62 +1,138 @@
+use super::command::CommandResponse;
 use crate::helpers::block_explorer::LinkProvider;
+use crate::response::cast_message::SncastMessage;
+use crate::response::declare::DeclareTransactionResponse;
+use crate::response::explorer_link::OutputLink;
 use conversions::string::IntoPaddedHexStr;
 use conversions::{padded_felt::PaddedFelt, serde::serialize::CairoSerialize};
 use foundry_ui::Message;
 use foundry_ui::styling;
 use indoc::formatdoc;
 use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use serde_json::json;
+use serde_json::{Value, json};
 
-use super::{command::CommandResponse, explorer_link::OutputLink};
-use crate::response::cast_message::SncastMessage;
+#[derive(Clone, Serialize, Deserialize, CairoSerialize, Debug, PartialEq)]
+#[serde(untagged)]
+pub enum DeployResponseKind {
+    Deploy(DeployResponse),
+    DeployWithDeclare(DeployResponseWithDeclare),
+}
+
+impl CommandResponse for DeployResponseKind {}
+
+impl Message for SncastMessage<DeployResponseKind> {
+    fn text(&self) -> String {
+        match &self.command_response {
+            DeployResponseKind::Deploy(response) => response.text(),
+            DeployResponseKind::DeployWithDeclare(response) => response.text(),
+        }
+    }
+
+    fn json(&self) -> Value {
+        serde_json::to_value(&self.command_response).unwrap_or_else(|err| {
+            json!({
+                "error": "Failed to serialize response",
+                "command": self.command,
+                "details": err.to_string()
+            })
+        })
+    }
+}
+
+impl OutputLink for DeployResponseKind {
+    const TITLE: &'static str = "deployment";
+
+    fn format_links(&self, provider: Box<dyn LinkProvider>) -> String {
+        match self {
+            DeployResponseKind::Deploy(deploy) => {
+                formatdoc!(
+                    "
+                    contract: {}
+                    transaction: {}
+                    ",
+                    provider.contract(deploy.contract_address),
+                    provider.transaction(deploy.transaction_hash)
+                )
+            }
+            DeployResponseKind::DeployWithDeclare(deploy_with_declare) => {
+                formatdoc!(
+                    "
+                    contract: {}
+                    class: {}
+                    declare transaction: {}
+                    deploy transaction: {}
+                    ",
+                    provider.contract(deploy_with_declare.contract_address),
+                    provider.class(deploy_with_declare.class_hash),
+                    provider.transaction(deploy_with_declare.declare_transaction_hash),
+                    provider.transaction(deploy_with_declare.deploy_transaction_hash)
+                )
+            }
+        }
+    }
+}
 
 #[derive(Clone, Serialize, Deserialize, CairoSerialize, Debug, PartialEq)]
 pub struct DeployResponse {
     pub contract_address: PaddedFelt,
     pub transaction_hash: PaddedFelt,
 }
 
-impl CommandResponse for DeployResponse {}
-
-impl Message for SncastMessage<DeployResponse> {
+impl DeployResponse {
     fn text(&self) -> String {
         styling::OutputBuilder::new()
             .success_message("Deployment completed")
             .blank_line()
             .field(
                 "Contract Address",
-                &self.command_response.contract_address.into_padded_hex_str(),
+                &self.contract_address.into_padded_hex_str(),
             )
             .field(
                 "Transaction Hash",
-                &self.command_response.transaction_hash.into_padded_hex_str(),
+                &self.transaction_hash.into_padded_hex_str(),
             )
             .build()
     }
+}
 
-    fn json(&self) -> Value {
-        serde_json::to_value(&self.command_response).unwrap_or_else(|err| {
-            json!({
-                "error": "Failed to serialize response",
-                "command": self.command,
-                "details": err.to_string()
-            })
-        })
-    }
+#[derive(Clone, Serialize, Deserialize, CairoSerialize, Debug, PartialEq)]
+pub struct DeployResponseWithDeclare {
+    pub contract_address: PaddedFelt,
+    pub class_hash: PaddedFelt,
+    pub deploy_transaction_hash: PaddedFelt,
+    pub declare_transaction_hash: PaddedFelt,
 }
 
-impl OutputLink for DeployResponse {
-    const TITLE: &'static str = "deployment";
+impl DeployResponseWithDeclare {
+    #[must_use]
+    pub fn from_responses(deploy: &DeployResponse, declare: &DeclareTransactionResponse) -> Self {
+        Self {
+            contract_address: deploy.contract_address,
+            class_hash: declare.class_hash,
+            deploy_transaction_hash: deploy.transaction_hash,
+            declare_transaction_hash: declare.transaction_hash,
+        }
+    }
+}
 
-    fn format_links(&self, provider: Box<dyn LinkProvider>) -> String {
-        formatdoc!(
-            "
-            contract: {}
-            transaction: {}
-            ",
-            provider.contract(self.contract_address),
-            provider.transaction(self.transaction_hash)
-        )
+impl DeployResponseWithDeclare {
+    fn text(&self) -> String {
+        styling::OutputBuilder::new()
+            .success_message("Deployment completed")
+            .blank_line()
+            .field(
+                "Contract Address",
+                &self.contract_address.into_padded_hex_str(),
+            )
+            .field("Class Hash", &self.class_hash.into_padded_hex_str())
+            .field(
+                "Declare Transaction Hash",
+                &self.declare_transaction_hash.into_padded_hex_str(),
+            )
+            .field(
+                "Deploy Transaction Hash",
+                &self.deploy_transaction_hash.into_padded_hex_str(),
+            )
+            .build()
     }
 }
diff --git a/crates/sncast/src/starknet_commands/deploy.rs b/crates/sncast/src/starknet_commands/deploy.rs
@@ -17,12 +17,22 @@ use starknet::providers::jsonrpc::HttpTransport;
 use starknet::signers::LocalWallet;
 use starknet_types_core::felt::Felt;
 
+#[derive(Args, Debug, Clone)]
+#[group(required = true, multiple = false)]
+pub struct DeployIdentifier {
+    /// Class hash of contract to deploy
+    #[arg(short = 'g', long)]
+    pub class_hash: Option<Felt>,
+
+    #[arg(long, conflicts_with = "class_hash")]
+    pub contract_name: Option<String>,
+}
+
 #[derive(Args)]
 #[command(about = "Deploy a contract on Starknet")]
 pub struct Deploy {
-    /// Class hash of contract to deploy
-    #[arg(short = 'g', long)]
-    pub class_hash: Felt,
+    #[command(flatten)]
+    pub identifier: DeployIdentifier,
 
     #[command(flatten)]
     pub arguments: DeployArguments,
diff --git a/crates/sncast/tests/e2e/deploy.rs b/crates/sncast/tests/e2e/deploy.rs
diff --git a/docs/src/starknet/deploy.md b/docs/src/starknet/deploy.md
