Feat(sncast): Add utility for calculating a contract's class hash

CHANGELOG.md

@@ -28,6 +28,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - A bug that caused `#[fuzzer]` attribute to fail when used with generic structs
 
+### Cast
+
+#### Added
+
+- `class-hash` command to calculate and return the class hash for a contract
+
 ## [0.48.0] - 2025-08-05
 
 ### Forge

crates/sncast/src/main.rs

@@ -1,3 +1,4 @@
+use crate::starknet_commands::class_hash::ClassHash;
 use crate::starknet_commands::deploy::DeployArguments;
 use crate::starknet_commands::multicall;
 use crate::starknet_commands::script::run_script_command;
@@ -124,6 +125,9 @@ enum Commands {
     /// Call a contract
     Call(Call),
 
+    /// Get contract class hash
+    ClassHash(ClassHash),
+
     /// Invoke a contract
     Invoke(Invoke),
 
@@ -370,6 +374,30 @@ async fn run_async_command(cli: Cli, config: CastConfig, ui: &UI) -> Result<()>
             Ok(())
         }
 
+        Commands::ClassHash(class_hash) => {
+            let manifest_path = assert_manifest_path_exists()?;
+            let package_metadata = get_package_metadata(&manifest_path, &class_hash.package)?;
+
+            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 result = starknet_commands::class_hash::get_class_hash(class_hash, &artifacts)
+                .map_err(handle_starknet_command_error);
+
+            process_command_result("class-hash", result, ui, None);
+
+            Ok(())
+        }
+
         Commands::Invoke(invoke) => {
             let Invoke {
                 contract_address,

crates/sncast/src/response/class_hash.rs

@@ -0,0 +1,67 @@
+use conversions::{padded_felt::PaddedFelt, serde::serialize::CairoSerialize, string::IntoHexStr};
+use foundry_ui::{Message, styling};
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+
+use crate::response::{cast_message::SncastMessage, command::CommandResponse};
+
+#[derive(Clone, Serialize, Deserialize, CairoSerialize, Debug, PartialEq)]
+pub struct ClassHashGeneratedResponse {
+    pub class_hash: PaddedFelt,
+}
+
+impl CommandResponse for ClassHashGeneratedResponse {}
+
+impl Message for SncastMessage<ClassHashGeneratedResponse> {
+    fn text(&self) -> String {
+        styling::OutputBuilder::new()
+            .success_message("Class hash generated")
+            .blank_line()
+            .field(
+                "Class Hash",
+                &self.command_response.class_hash.into_hex_string(),
+            )
+            .build()
+    }
+
+    fn json(&self) -> serde_json::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)]
+#[serde(tag = "status")]
+pub enum ClassHashResponse {
+    #[serde(untagged)]
+    Success(ClassHashGeneratedResponse),
+}
+
+impl CommandResponse for ClassHashResponse {}
+
+impl Message for SncastMessage<ClassHashResponse> {
+    fn text(&self) -> String {
+        match &self.command_response {
+            ClassHashResponse::Success(response) => styling::OutputBuilder::new()
+                .success_message("Class hash generated")
+                .blank_line()
+                .field("Class Hash", &response.class_hash.into_hex_string())
+                .build(),
+        }
+    }
+
+    fn json(&self) -> serde_json::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()
+            })
+        })
+    }
+}

crates/sncast/src/response/mod.rs

@@ -1,6 +1,7 @@
 pub mod account;
 pub mod call;
 pub mod cast_message;
+pub mod class_hash;
 pub mod command;
 pub mod declare;
 pub mod deploy;

crates/sncast/src/starknet_commands/class_hash.rs

@@ -0,0 +1,47 @@
+use anyhow::Context;
+use clap::Args;
+use conversions::{IntoConv, byte_array::ByteArray};
+use scarb_api::StarknetContractArtifacts;
+use sncast::{
+    ErrorData,
+    response::{
+        class_hash::{ClassHashGeneratedResponse, ClassHashResponse},
+        errors::StarknetCommandError,
+    },
+};
+use starknet::core::types::contract::SierraClass;
+use std::collections::HashMap;
+
+#[derive(Args)]
+#[command(about = "Generate the class hash of a contract", long_about = None)]
+pub struct ClassHash {
+    /// Contract name
+    #[arg(short = 'c', long = "contract-name")]
+    pub contract: String,
+
+    /// Specifies scarb package to be used
+    #[arg(long)]
+    pub package: Option<String>,
+}
+
+pub fn get_class_hash(
+    class_hash: ClassHash,
+    artifacts: &HashMap<String, StarknetContractArtifacts>,
+) -> Result<ClassHashResponse, StarknetCommandError> {
+    let contract_artifacts = artifacts.get(&class_hash.contract).ok_or(
+        StarknetCommandError::ContractArtifactsNotFound(ErrorData {
+            data: ByteArray::from(class_hash.contract.as_str()),
+        }),
+    )?;
+
+    let contract_definition: SierraClass = serde_json::from_str(&contract_artifacts.sierra)
+        .context("Failed to parse sierra artifact")?;
+
+    let class_hash = contract_definition
+        .class_hash()
+        .map_err(anyhow::Error::from)?;
+
+    Ok(ClassHashResponse::Success(ClassHashGeneratedResponse {
+        class_hash: class_hash.into_(),
+    }))
+}

crates/sncast/src/starknet_commands/mod.rs

@@ -1,5 +1,6 @@
 pub mod account;
 pub mod call;
+pub mod class_hash;
 pub mod declare;
 pub mod deploy;
 pub mod invoke;

crates/sncast/tests/e2e/class_hash.rs

@@ -0,0 +1,29 @@
+use crate::helpers::{
+    constants::CONTRACTS_DIR, fixtures::duplicate_contract_directory_with_salt, runner::runner,
+};
+use indoc::indoc;
+use shared::test_utils::output_assert::assert_stdout_contains;
+
+#[test]
+fn test_happy_case_get_class_hash() {
+    let contract_path = duplicate_contract_directory_with_salt(
+        CONTRACTS_DIR.to_string() + "/map",
+        "put",
+        "human_readable",
+    );
+
+    let args = vec!["class-hash", "--contract-name", "Map"];
+
+    let snapbox = runner(&args).current_dir(contract_path.path());
+
+    let output = snapbox.assert().success();
+
+    assert_stdout_contains(
+        output,
+        indoc! {r"
+        Success: Class hash generated
+
+        Class Hash: 0x6ee50dd7f45bd73b5e0e6f3c32013529f31477af0103c4c593915b6c1d6eefe
+    "},
+    );
+}

crates/sncast/tests/e2e/mod.rs

@@ -1,5 +1,6 @@
 mod account;
 mod call;
+mod class_hash;
 mod completions;
 mod declare;
 mod deploy;

docs/src/starknet/class_hash.md

@@ -0,0 +1,25 @@
+# Calculate contract class hash
+
+## Overview
+Use `sncast`'s `class-hash` command to calculate the class hash of a contract.
+
+## Examples
+
+### General Example
+
+```shell
+$ sncast \
+  class-hash \
+  --contract-name CheatcodeChecker
+```
+
+<details>
+<summary>Output:</summary>
+
+```shell
+Success: Class Hash generated
+
+Class Hash: 0x0[..]
+```
+</details>
+<br>