Introduced by-name deployment and declare-deploy command

CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Cast
+
+### Added
+- `sncast deploy` can now deploy contracts by name instead of class hash. [Read more here](https://foundry-rs.github.io/starknet-foundry/starknet/deploy.html)
+- `sncast declare-deploy` allows to declare and deploy contract at once. [Read more here](https://foundry-rs.github.io/starknet-foundry/starknet/declare-deploy.html)
+
 ## [0.28.0] - 2024-08-21
 
 ### Forge

crates/sncast/src/helpers/deploy.rs

@@ -0,0 +1,35 @@
+use clap::{Args, ValueEnum};
+use starknet_crypto::FieldElement;
+
+#[derive(ValueEnum, Debug, Clone)]
+pub enum DeployVersion {
+    V1,
+    V3,
+}
+
+#[derive(Args)]
+pub struct DeployArgs {
+    // A package to deploy a contract from
+    #[clap(long)]
+    pub package: Option<String>,
+
+    /// Calldata for the contract constructor
+    #[clap(short, long, value_delimiter = ' ', num_args = 1..)]
+    pub constructor_calldata: Vec<FieldElement>,
+
+    /// Salt for the address
+    #[clap(short, long)]
+    pub salt: Option<FieldElement>,
+
+    /// If true, salt will be modified with an account address
+    #[clap(long)]
+    pub unique: bool,
+
+    /// Nonce of the transaction. If not provided, nonce will be set automatically
+    #[clap(short, long)]
+    pub nonce: Option<FieldElement>,
+
+    /// Version of the deployment
+    #[clap(short, long)]
+    pub version: Option<DeployVersion>,
+}

crates/sncast/src/helpers/fee.rs

@@ -4,7 +4,7 @@ use conversions::serde::deserialize::CairoDeserialize;
 use starknet::core::types::{BlockId, FieldElement};
 use starknet::providers::Provider;
 
-#[derive(Args, Debug, Clone)]
+#[derive(Args, Debug, Clone, Default)]
 pub struct FeeArgs {
     /// Token that transaction fee will be paid in
     #[clap(long)]

crates/sncast/src/helpers/mod.rs

@@ -2,6 +2,7 @@ pub mod block_explorer;
 pub mod braavos;
 pub mod configuration;
 pub mod constants;
+pub mod deploy;
 pub mod error;
 pub mod fee;
 pub mod rpc;

crates/sncast/src/helpers/scarb_utils.rs

@@ -1,4 +1,4 @@
-use anyhow::{anyhow, Context, Result};
+use anyhow::{anyhow, bail, Context, Result};
 use camino::{Utf8Path, Utf8PathBuf};
 use scarb_api::{
     get_contracts_artifacts_and_source_sierra_paths,
@@ -7,6 +7,14 @@ use scarb_api::{
 };
 use scarb_ui::args::PackagesFilter;
 use shared::{command::CommandExt, print::print_as_warning};
+use starknet::{
+    core::types::{
+        contract::{CompiledClass, SierraClass},
+        BlockId, FlattenedSierraClass,
+    },
+    providers::{jsonrpc::HttpTransport, JsonRpcClient, Provider, ProviderError},
+};
+use starknet_crypto::FieldElement;
 use std::collections::HashMap;
 use std::env;
 use std::str::FromStr;
@@ -176,6 +184,70 @@ pub fn build_and_load_artifacts(
     }
 }
 
+pub fn read_manifest_and_build_artifacts(
+    package: &Option<String>,
+    json: bool,
+    profile: &Option<String>,
+) -> Result<HashMap<String, StarknetContractArtifacts>> {
+    let manifest_path = assert_manifest_path_exists()?;
+    let package_metadata = get_package_metadata(&manifest_path, package)?;
+
+    let profile = profile.to_owned().unwrap_or("dev".to_string());
+
+    let build_config = BuildConfig {
+        scarb_toml_path: manifest_path,
+        json,
+        profile,
+    };
+
+    build_and_load_artifacts(&package_metadata, &build_config).context("Failed to build contract")
+}
+
+pub struct CompiledContract {
+    pub class: FlattenedSierraClass,
+    pub sierra_class_hash: FieldElement,
+    pub casm_class_hash: FieldElement,
+}
+
+impl TryFrom<&StarknetContractArtifacts> for CompiledContract {
+    type Error = anyhow::Error;
+
+    fn try_from(artifacts: &StarknetContractArtifacts) -> Result<Self, Self::Error> {
+        let sierra_class = serde_json::from_str::<SierraClass>(&artifacts.sierra)
+            .context("Failed to parse Sierra artifact")?
+            .flatten()?;
+
+        let compiled_class = serde_json::from_str::<CompiledClass>(&artifacts.casm)
+            .context("Failed to parse CASM artifact")?;
+
+        let sierra_class_hash = sierra_class.class_hash();
+        let casm_class_hash = compiled_class.class_hash()?;
+
+        Ok(Self {
+            class: sierra_class,
+            sierra_class_hash,
+            casm_class_hash,
+        })
+    }
+}
+
+impl CompiledContract {
+    pub async fn is_declared(&self, provider: &JsonRpcClient<HttpTransport>) -> Result<bool> {
+        let block_id = BlockId::Tag(starknet::core::types::BlockTag::Pending);
+        let class_hash = self.sierra_class_hash;
+
+        let response = provider.get_class(block_id, class_hash).await;
+
+        match response {
+            Ok(_) => Ok(true),
+            Err(ProviderError::StarknetError(
+                starknet::core::types::StarknetError::ClassHashNotFound,
+            )) => Ok(false),
+            Err(other) => bail!(other),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::helpers::scarb_utils::{get_package_metadata, get_scarb_metadata};

crates/sncast/src/main.rs

@@ -4,7 +4,7 @@ use crate::starknet_commands::{
     account, call::Call, declare::Declare, deploy::Deploy, invoke::Invoke, multicall::Multicall,
     script::Script, tx_status::TxStatus,
 };
-use anyhow::{Context, Result};
+use anyhow::{bail, Context, Result};
 use configuration::load_global_config;
 use sncast::response::explorer_link::print_block_explorer_link_if_allowed;
 use sncast::response::print::{print_command_result, OutputFormat};
@@ -16,15 +16,18 @@ use sncast::helpers::constants::{DEFAULT_ACCOUNTS_FILE, DEFAULT_MULTICALL_CONTEN
 use sncast::helpers::fee::PayableTransaction;
 use sncast::helpers::scarb_utils::{
     assert_manifest_path_exists, build, build_and_load_artifacts, get_package_metadata,
-    get_scarb_metadata_with_deps, BuildConfig,
+    get_scarb_metadata_with_deps, read_manifest_and_build_artifacts, BuildConfig,
 };
 use sncast::response::errors::handle_starknet_command_error;
+use sncast::response::structs::DeclareDeployResponse;
 use sncast::{
     chain_id_to_network_name, get_account, get_block_id, get_chain_id, get_default_state_file_name,
     NumbersFormat, ValidatedWaitParams, WaitForTx,
 };
 use starknet::core::utils::get_selector_from_name;
 use starknet_commands::account::list::print_account_list;
+use starknet_commands::declare_deploy::DeclareDeploy;
+use starknet_commands::deploy::DeployResolved;
 use starknet_commands::verify::Verify;
 use tokio::runtime::Runtime;
 
@@ -118,6 +121,9 @@ enum Commands {
     /// Deploy a contract
     Deploy(Deploy),
 
+    // Declare a contract if it has not been yet and deploy it
+    DeclareDeploy(DeclareDeploy),
+
     /// Call a contract
     Call(Call),
 
@@ -191,17 +197,10 @@ async fn run_async_command(
                 config.keystore,
             )
             .await?;
-            let manifest_path = assert_manifest_path_exists()?;
-            let package_metadata = get_package_metadata(&manifest_path, &declare.package)?;
-            let artifacts = build_and_load_artifacts(
-                &package_metadata,
-                &BuildConfig {
-                    scarb_toml_path: manifest_path,
-                    json: cli.json,
-                    profile: cli.profile.unwrap_or("dev".to_string()),
-                },
-            )
-            .expect("Failed to build contract");
+
+            let artifacts =
+                read_manifest_and_build_artifacts(&declare.package, cli.json, &cli.profile)?;
+
             let result =
                 starknet_commands::declare::declare(declare, &account, &artifacts, wait_config)
                     .await
@@ -215,7 +214,6 @@ async fn run_async_command(
         Commands::Deploy(deploy) => {
             let provider = deploy.rpc.get_provider(&config).await?;
 
-            deploy.validate()?;
             let account = get_account(
                 &config.account,
                 &config.accounts_file,
@@ -224,6 +222,22 @@ async fn run_async_command(
             )
             .await?;
 
+            let deploy: DeployResolved = if deploy.class_hash.is_some() {
+                deploy.try_into().unwrap()
+            } else {
+                let contract =
+                    deploy.build_artifacts_and_get_compiled_contract(cli.json, &cli.profile)?;
+                let class_hash = contract.sierra_class_hash;
+
+                if !contract.is_declared(&provider).await? {
+                    bail!("Contract with class hash {:x} is not declared", class_hash);
+                }
+
+                deploy.resolved_with_class_hash(class_hash)
+            };
+
+            deploy.validate()?;
+
             let result = starknet_commands::deploy::deploy(deploy, &account, wait_config)
                 .await
                 .map_err(handle_starknet_command_error);
@@ -233,6 +247,76 @@ async fn run_async_command(
             Ok(())
         }
 
+        Commands::DeclareDeploy(declare_deploy) => {
+            let provider = declare_deploy.rpc.get_provider(&config).await?;
+
+            let account = get_account(
+                &config.account,
+                &config.accounts_file,
+                &provider,
+                config.keystore,
+            )
+            .await?;
+
+            let declare = Declare::from(&declare_deploy);
+            let deploy = Deploy::from(declare_deploy);
+
+            let contract =
+                deploy.build_artifacts_and_get_compiled_contract(cli.json, &cli.profile)?;
+            let class_hash = contract.sierra_class_hash;
+
+            let needs_declaration = !contract.is_declared(&provider).await?;
+
+            let declare_result = if needs_declaration {
+                let result = crate::starknet_commands::declare::declare_compiled(
+                    declare,
+                    &account,
+                    contract,
+                    wait_config,
+                )
+                .await
+                .map_err(handle_starknet_command_error);
+
+                if result.is_err() {
+                    return print_command_result(
+                        "declare-deploy",
+                        &result,
+                        numbers_format,
+                        output_format,
+                    );
+                }
+
+                Some(result.unwrap())
+            } else {
+                None
+            };
+
+            let deploy = deploy.resolved_with_class_hash(class_hash);
+            deploy.validate()?;
+
+            let deploy_result = starknet_commands::deploy::deploy(deploy, &account, wait_config)
+                .await
+                .map_err(handle_starknet_command_error);
+
+            if deploy_result.is_err() {
+                return print_command_result(
+                    "declare-deploy",
+                    &deploy_result,
+                    numbers_format,
+                    output_format,
+                );
+            }
+
+            let result = Ok(DeclareDeployResponse::new(
+                &declare_result,
+                deploy_result.unwrap(),
+            ));
+
+            print_command_result("declare-deploy", &result, numbers_format, output_format)?;
+            print_block_explorer_link_if_allowed(&result, output_format, config.block_explorer);
+            Ok(())
+        }
+
         Commands::Call(call) => {
             let provider = call.rpc.get_provider(&config).await?;