add: fast flags

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "madara-cli"
 version = "0.2.0"
-edition = "2024"
+edition = "2021"
 
 [[bin]]
 name = "madara"

src/app/config.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 use strum::EnumIter;
-use strum_macros::Display;
+use strum_macros::{Display, EnumString};
 use toml::ser::Error;
 
 use crate::da::da_layers::DALayer;
@@ -24,7 +24,7 @@ impl AppChainConfig {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, EnumIter, Display)]
+#[derive(Debug, Serialize, Deserialize, EnumIter, Display, Clone, EnumString)]
 pub enum RollupMode {
     Sovereign,
     // Validity,

src/cli/init.rs

@@ -1,4 +1,5 @@
 use std::{fs, io};
+use std::str::FromStr;
 
 use inquire::InquireError;
 use strum::IntoEnumIterator;
@@ -24,10 +25,12 @@ pub enum InitError {
     FailedToSerializeToToml(#[from] toml::ser::Error),
     #[error("Failed to generate keypair")]
     FailedToGenerateKeypair,
+    #[error("Failed to convert string to enum")]
+    FailedToGetEnum(#[from] strum::ParseError),
 }
 
-pub async fn init() {
-    let config = match generate_config().await {
+pub async fn init(chain_name: &Option<String>, chain_mode: &Option<String>, da: &Option<String>) {
+    let config = match generate_config(chain_name, chain_mode, da).await {
         Ok(config) => config,
         Err(err) => {
             panic!("Failed to get input: {}", err);
@@ -44,15 +47,29 @@ pub async fn init() {
     log::info!("✅ New app chain initialised.");
 }
 
-async fn generate_config() -> Result<AppChainConfig, InitError> {
-    let app_chain = get_text_input("Enter you app chain name:", Some("madara"))?;
+async fn generate_config(chain_name: &Option<String>, chain_mode: &Option<String>, da: &Option<String>) -> Result<AppChainConfig, InitError> {
+    let app_chain: String;
+    match chain_name {
+        Some(chain_name) => app_chain = chain_name.clone(),
+        None => app_chain = get_text_input("Enter you app chain name:", Some("madara"))?,
+    }
 
     let app_chains_home = get_app_chains_home()?;
     let binding = app_chains_home.join(format!("{}/data", app_chain));
     let default_base_path = binding.to_str().unwrap_or("madara-data");
 
-    let mode = get_option("Select mode for your app chain:", RollupMode::iter().collect::<Vec<_>>())?;
-    let da_layer = get_option("Select DA layer for your app chain:", DALayer::iter().collect::<Vec<_>>())?;
+    let mode: RollupMode;
+    match chain_mode {
+        Some(chain_mode) => mode = RollupMode::from_str(chain_mode)?,
+        None => mode = get_option("Select mode for your app chain:", RollupMode::iter().collect::<Vec<_>>())?,
+    }
+
+    let da_layer: DALayer;
+    match da {
+        Some(da) => da_layer = DALayer::from_str(da)?,
+        None => da_layer = get_option("Select DA layer for your app chain:", DALayer::iter().collect::<Vec<_>>())?,
+    }
+
     let madara_version = get_latest_commit_hash(MADARA_REPO_ORG, MADARA_REPO_NAME, MADARA_BRANCH_NAME).await?;
     let config_version = ConfigVersion::Version2;
 

src/cli/run.rs

@@ -24,8 +24,8 @@ pub enum RunError {
     Other(#[from] eyre::Error),
 }
 
-pub async fn run() {
-    match start_app_chain().await {
+pub async fn run(chain_name: &Option<String>) {
+    match start_app_chain(chain_name).await {
         Ok(_) => {
             log::info!("Madara setup successful");
         }
@@ -35,12 +35,18 @@ pub async fn run() {
     }
 }
 
-async fn start_app_chain() -> Result<(), RunError> {
-    let app_chains_list = get_apps_list()?;
-    let app = get_option("Select the app chain:", app_chains_list)?;
-    let app_chain: &str = &app;
+async fn start_app_chain(chain_name: &Option<String>) -> Result<(), RunError> {
+    let app_chain: String;
+    match chain_name {
+        Some(chain_name) => app_chain = chain_name.to_string(),
+        None => {
+            let app_chains_list = get_apps_list()?;
+            let app = get_option("Select the app chain:", app_chains_list)?;
+            app_chain = app;
+        }
+    }
 
-    let (config, _) = match regenerate_app_config(app_chain) {
+    let (config, _) = match regenerate_app_config(&app_chain) {
         Ok((config, valid)) => (config, valid),
         Err(err) => {
             log::error!("Failed to fetch the required app chain: {}", err);

src/da/da_layers.rs

@@ -3,7 +3,7 @@ use std::io;
 use std::path::PathBuf;
 
 use serde::{Deserialize, Serialize};
-use strum_macros::{Display, EnumIter};
+use strum_macros::{Display, EnumIter, EnumString};
 use thiserror::Error;
 
 use crate::app::config::AppChainConfig;
@@ -15,7 +15,7 @@ use crate::utils::constants::APP_DA_CONFIG_NAME;
 use crate::utils::paths::get_app_home;
 use eyre::Result as EyreResult;
 
-#[derive(Debug, Serialize, Deserialize, EnumIter, Display, Clone)]
+#[derive(Debug, Serialize, Deserialize, EnumIter, Display, Clone, EnumString)]
 pub enum DALayer {
     Avail,
     Ethereum,

src/main.rs

@@ -13,11 +13,25 @@ struct Cli {
 #[derive(Subcommand)]
 enum Commands {
     /// Init a new App Chain config
-    Init,
+    Init {
+        /// App chain name
+        #[arg(short, long)]
+        chain_name: Option<String>,
+        /// Select Sovereign
+        #[arg(short, long)]
+        chain_mode: Option<String>,
+        /// Select between Avail, Celestia, Ethereum, NoDA
+        #[arg(short, long)]
+        da: Option<String>
+    },
     /// Lists all the existing App Chain configs
     List,
     /// Runs the App Chain using Madara
-    Run,
+    Run {
+        /// App chain name
+        #[arg(short, long)]
+        chain_name: Option<String>,
+    },
     /// Runs the L2 explorer
     Explorer(ExplorerOpts),
 }
@@ -34,9 +48,9 @@ async fn main() {
     let cli = Cli::parse();
 
     match &cli.command {
-        Some(Commands::Init) => cli::init::init().await,
+        Some(Commands::Init{chain_name, chain_mode, da}) => cli::init::init(chain_name, chain_mode, da).await,
         Some(Commands::List) => cli::list::list(),
-        Some(Commands::Run) => cli::run::run().await,
+        Some(Commands::Run{chain_name}) => cli::run::run(chain_name).await,
         Some(Commands::Explorer(opts)) => cli::explorer::explorer(opts).await,
         None => log::info!("Use --help to see the complete list of available commands"),
     }