Introduced by-name deployment and declare-deploy command

CHANGELOG.md

@@ -7,6 +7,13 @@ 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).
+
 ### Forge
 
 #### Changed

crates/sncast/src/helpers/deploy.rs

@@ -0,0 +1,35 @@
+use clap::{Args, ValueEnum};
+use starknet::core::types::Felt;
+
+#[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<Felt>,
+
+    /// Salt for the address
+    #[clap(short, long)]
+    pub salt: Option<Felt>,
+
+    /// 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<Felt>,
+
+    /// Version of the deployment
+    #[clap(short, long)]
+    pub version: Option<DeployVersion>,
+}

crates/sncast/src/helpers/fee.rs

@@ -6,7 +6,7 @@ use starknet::core::types::{BlockId, Felt};
 use starknet::providers::Provider;
 use starknet_types_core::felt::NonZeroFelt;
 
-#[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,15 @@ use scarb_api::{
 };
 use scarb_ui::args::PackagesFilter;
 use shared::{command::CommandExt, print::print_as_warning};
+use starknet::core::types::Felt;
+use starknet::{
+    core::types::{
+        contract::{CompiledClass, SierraClass},
+        BlockId, FlattenedSierraClass,
+    },
+    providers::{jsonrpc::HttpTransport, JsonRpcClient, Provider, ProviderError},
+};
+
 use std::collections::HashMap;
 use std::env;
 use std::str::FromStr;
@@ -188,6 +197,71 @@ 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, false)
+        .context("Failed to build contract")
+}
+
+pub struct CompiledContract {
+    pub class: FlattenedSierraClass,
+    pub sierra_class_hash: Felt,
+    pub casm_class_hash: Felt,
+}
+
+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};