Remove account type enum redundancy (#2946)

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

Closes #2571

## Introduced changes

<!-- A brief description of the changes -->

-

## Checklist

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

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

Author: RichoKD

crates/sncast/src/lib.rs

@@ -47,7 +47,7 @@ use conversions::byte_array::ByteArray;
 
 pub type NestedMap<T> = HashMap<String, HashMap<String, T>>;
 
-#[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq, Eq, ValueEnum)]
 #[serde(rename_all = "lowercase")]
 pub enum AccountType {
     #[serde(rename = "open_zeppelin")]
@@ -61,7 +61,7 @@ impl FromStr for AccountType {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "open_zeppelin" | "oz" => Ok(AccountType::OpenZeppelin),
+            "open_zeppelin" | "open-zeppelin" | "oz" => Ok(AccountType::OpenZeppelin),
             "argent" => Ok(AccountType::Argent),
             "braavos" => Ok(AccountType::Braavos),
             account_type => Err(anyhow!("Invalid account type = {account_type}")),

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

@@ -1,6 +1,5 @@
 use crate::starknet_commands::account::{
-    AccountType, add_created_profile_to_configuration, prepare_account_json,
-    write_account_to_accounts_file,
+    add_created_profile_to_configuration, prepare_account_json, write_account_to_accounts_file,
 };
 use anyhow::{Context, Result, anyhow, bail};
 use camino::Utf8PathBuf;
@@ -16,8 +15,8 @@ use sncast::helpers::constants::{
 use sncast::helpers::rpc::RpcArgs;
 use sncast::response::structs::AccountCreateResponse;
 use sncast::{
-    Network, check_class_hash_exists, check_if_legacy_contract, extract_or_generate_salt,
-    get_chain_id, get_keystore_password, handle_account_factory_error,
+    AccountType, Network, check_class_hash_exists, check_if_legacy_contract,
+    extract_or_generate_salt, get_chain_id, get_keystore_password, handle_account_factory_error,
 };
 use starknet::accounts::{
     AccountDeploymentV1, AccountFactory, ArgentAccountFactory, OpenZeppelinAccountFactory,
@@ -27,12 +26,13 @@ use starknet::providers::JsonRpcClient;
 use starknet::providers::jsonrpc::HttpTransport;
 use starknet::signers::{LocalWallet, SigningKey};
 use starknet_types_core::felt::Felt;
+use std::str::FromStr;
 
 #[derive(Args, Debug)]
 #[command(about = "Create an account with all important secrets")]
 pub struct Create {
     /// Type of the account
-    #[clap(value_enum, short = 't', long = "type", default_value_t = AccountType::Oz)]
+    #[clap(value_enum, short = 't', long = "type", value_parser = AccountType::from_str, default_value_t = AccountType::OpenZeppelin)]
     pub account_type: AccountType,
 
     /// Account name under which account information is going to be saved
@@ -70,14 +70,14 @@ pub async fn create(
     let add_profile = create.add_profile.clone();
     let salt = extract_or_generate_salt(create.salt);
     let class_hash = create.class_hash.unwrap_or(match create.account_type {
-        AccountType::Oz => OZ_CLASS_HASH,
+        AccountType::OpenZeppelin => OZ_CLASS_HASH,
         AccountType::Argent => ARGENT_CLASS_HASH,
         AccountType::Braavos => BRAAVOS_CLASS_HASH,
     });
     check_class_hash_exists(provider, class_hash).await?;
 
     let (account_json, max_fee) =
-        generate_account(provider, salt, class_hash, &create.account_type).await?;
+        generate_account(provider, salt, class_hash, create.account_type).await?;
 
     let address: Felt = account_json["address"]
         .as_str()
@@ -104,7 +104,7 @@ pub async fn create(
             private_key,
             salt,
             class_hash,
-            &create.account_type,
+            create.account_type,
             &keystore,
             &account_path,
             legacy,
@@ -167,14 +167,14 @@ async fn generate_account(
     provider: &JsonRpcClient<HttpTransport>,
     salt: Felt,
     class_hash: Felt,
-    account_type: &AccountType,
+    account_type: AccountType,
 ) -> Result<(serde_json::Value, Felt)> {
     let chain_id = get_chain_id(provider).await?;
     let private_key = SigningKey::from_random();
     let signer = LocalWallet::from_signing_key(private_key.clone());
 
     let (address, fee_estimate) = match account_type {
-        AccountType::Oz => {
+        AccountType::OpenZeppelin => {
             let factory =
                 OpenZeppelinAccountFactory::new(class_hash, chain_id, signer, provider).await?;
             get_address_and_deployment_fee(factory, salt).await?
@@ -245,7 +245,7 @@ fn create_to_keystore(
     private_key: Felt,
     salt: Felt,
     class_hash: Felt,
-    account_type: &AccountType,
+    account_type: AccountType,
     keystore_path: &Utf8PathBuf,
     account_path: &Utf8PathBuf,
     legacy: bool,
@@ -259,13 +259,12 @@ fn create_to_keystore(
     let password = get_keystore_password(CREATE_KEYSTORE_PASSWORD_ENV_VAR)?;
     let private_key = SigningKey::from_secret_scalar(private_key);
     private_key.save_as_keystore(keystore_path, &password)?;
-
     let account_json = match account_type {
-        AccountType::Oz => {
+        AccountType::OpenZeppelin => {
             json!({
                 "version": 1,
                 "variant": {
-                    "type": format!("{account_type}"),
+                    "type": AccountType::OpenZeppelin,
                     "version": 1,
                     "public_key": format!("{:#x}", private_key.verifying_key().scalar()),
                     "legacy": legacy,
@@ -281,7 +280,7 @@ fn create_to_keystore(
             json!({
                 "version": 1,
                 "variant": {
-                    "type": format!("{account_type}"),
+                    "type": AccountType::Argent,
                     "version": 1,
                     "owner": format!("{:#x}", private_key.verifying_key().scalar()),
                     "guardian": "0x0",
@@ -298,7 +297,7 @@ fn create_to_keystore(
                 {
                   "version": 1,
                   "variant": {
-                    "type": format!("{account_type}"),
+                    "type": AccountType::Braavos,
                     "version": 1,
                     "multisig": {
                       "status": "off"

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

@@ -1,7 +1,8 @@
+use std::str::FromStr;
+
 use super::deploy::compute_account_address;
 use crate::starknet_commands::account::{
-    AccountType, add_created_profile_to_configuration, prepare_account_json,
-    write_account_to_accounts_file,
+    add_created_profile_to_configuration, prepare_account_json, write_account_to_accounts_file,
 };
 use anyhow::{Context, Result, bail, ensure};
 use camino::Utf8PathBuf;
@@ -12,9 +13,7 @@ use sncast::helpers::account::generate_account_name;
 use sncast::helpers::configuration::CastConfig;
 use sncast::helpers::rpc::RpcArgs;
 use sncast::response::structs::AccountImportResponse;
-use sncast::{
-    AccountType as SNCastAccountType, check_class_hash_exists, get_chain_id, handle_rpc_error,
-};
+use sncast::{AccountType, check_class_hash_exists, get_chain_id, handle_rpc_error};
 use starknet::core::types::{BlockId, BlockTag, StarknetError};
 use starknet::providers::jsonrpc::{HttpTransport, JsonRpcClient};
 use starknet::providers::{Provider, ProviderError};
@@ -33,7 +32,7 @@ pub struct Import {
     pub address: Felt,
 
     /// Type of the account
-    #[clap(short = 't', long = "type")]
+    #[clap(short = 't', long = "type", value_parser = AccountType::from_str)]
     pub account_type: AccountType,
 
     /// Class hash of the account
@@ -121,12 +120,7 @@ pub async fn import(
 
     let chain_id = get_chain_id(provider).await?;
     if let Some(salt) = import.salt {
-        // TODO(#2571)
-        let sncast_account_type = match import.account_type {
-            AccountType::Argent => SNCastAccountType::Argent,
-            AccountType::Braavos => SNCastAccountType::Braavos,
-            AccountType::Oz => SNCastAccountType::OpenZeppelin,
-        };
+        let sncast_account_type = import.account_type;
         let computed_address =
             compute_account_address(salt, private_key, class_hash, sncast_account_type, chain_id);
         ensure!(
@@ -144,7 +138,7 @@ pub async fn import(
         import.address,
         deployed,
         legacy,
-        &import.account_type,
+        import.account_type,
         Some(class_hash),
         import.salt,
     );

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

@@ -5,15 +5,17 @@ use crate::starknet_commands::account::import::Import;
 use crate::starknet_commands::account::list::List;
 use anyhow::{Context, Result, anyhow, bail};
 use camino::Utf8PathBuf;
-use clap::{Args, Subcommand, ValueEnum};
+use clap::{Args, Subcommand};
 use configuration::{
     CONFIG_FILENAME, find_config_file, load_config, search_config_upwards_relative_to,
 };
 use serde_json::json;
-use sncast::{chain_id_to_network_name, decode_chain_id, helpers::configuration::CastConfig};
+use sncast::{
+    AccountType, chain_id_to_network_name, decode_chain_id, helpers::configuration::CastConfig,
+};
 use starknet::signers::SigningKey;
 use starknet_types_core::felt::Felt;
-use std::{fmt, fs::OpenOptions, io::Write};
+use std::{fs::OpenOptions, io::Write};
 use toml::Value;
 
 pub mod create;
@@ -38,41 +40,20 @@ pub enum Commands {
     List(List),
 }
 
-#[expect(clippy::doc_markdown)]
-#[derive(ValueEnum, Clone, Debug)]
-pub enum AccountType {
-    /// OpenZeppelin account implementation
-    Oz,
-    /// Argent account implementation
-    Argent,
-    /// Braavos account implementation
-    Braavos,
-}
-
-impl fmt::Display for AccountType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            AccountType::Oz => write!(f, "open_zeppelin"),
-            AccountType::Argent => write!(f, "argent"),
-            AccountType::Braavos => write!(f, "braavos"),
-        }
-    }
-}
-
 pub fn prepare_account_json(
     private_key: &SigningKey,
     address: Felt,
     deployed: bool,
     legacy: bool,
-    account_type: &AccountType,
+    account_type: AccountType,
     class_hash: Option<Felt>,
     salt: Option<Felt>,
 ) -> serde_json::Value {
     let mut account_json = json!({
         "private_key": format!("{:#x}", private_key.secret_scalar()),
         "public_key": format!("{:#x}", private_key.verifying_key().scalar()),
         "address": format!("{address:#x}"),
-        "type": format!("{account_type}"),
+        "type": format!("{account_type}").to_lowercase().replace("openzeppelin", "open_zeppelin"),
         "deployed": deployed,
         "legacy": legacy,
     });