chg: take madara args as positional arg instead of a flag

src/app/config.rs

@@ -24,7 +24,7 @@ impl AppChainConfig {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, EnumIter, Display, Clone, EnumString)]
+#[derive(Debug, Serialize, Deserialize, EnumIter, Display, Clone, EnumString, clap::ValueEnum)]
 pub enum RollupMode {
     Sovereign,
     // Validity,

src/cli/explorer.rs

@@ -49,7 +49,7 @@ pub async fn explorer(opts: &ExplorerOpts) {
     }
 
     run_docker_image(
-        "ghcr.io/lambdaclass/stark_compass_explorer:v0.2.34.3-1",
+        "anshalshukla/starkcompass:latest",
         CONTAINER_NAME,
         Some(env),
         Some(host_config),

src/cli/init.rs

@@ -1,4 +1,3 @@
-use std::str::FromStr;
 use std::{fs, io};
 
 use inquire::InquireError;
@@ -29,7 +28,7 @@ pub enum InitError {
     FailedToGetEnum(#[from] strum::ParseError),
 }
 
-pub async fn init(chain_name: &Option<String>, chain_mode: &Option<String>, da: &Option<String>) {
+pub async fn init(chain_name: &Option<String>, chain_mode: &Option<RollupMode>, da: &Option<DALayer>) {
     let config = match generate_config(chain_name, chain_mode, da).await {
         Ok(config) => config,
         Err(err) => {
@@ -49,8 +48,8 @@ pub async fn init(chain_name: &Option<String>, chain_mode: &Option<String>, da:
 
 async fn generate_config(
     chain_name: &Option<String>,
-    chain_mode: &Option<String>,
-    da: &Option<String>,
+    chain_mode: &Option<RollupMode>,
+    da: &Option<DALayer>,
 ) -> Result<AppChainConfig, InitError> {
     let app_chain: String = match chain_name {
         Some(chain_name) => chain_name.clone(),
@@ -62,12 +61,12 @@ async fn generate_config(
     let default_base_path = binding.to_str().unwrap_or("madara-data");
 
     let mode: RollupMode = match chain_mode {
-        Some(chain_mode) => RollupMode::from_str(chain_mode)?,
+        Some(chain_mode) => chain_mode.clone(),
         None => get_option("Select mode for your app chain:", RollupMode::iter().collect::<Vec<_>>())?,
     };
 
     let da_layer: DALayer = match da {
-        Some(da) => DALayer::from_str(da)?,
+        Some(da) => da.clone(),
         None => get_option("Select DA layer for your app chain:", DALayer::iter().collect::<Vec<_>>())?,
     };
 

src/cli/run.rs

@@ -24,8 +24,8 @@ pub enum RunError {
     Other(#[from] eyre::Error),
 }
 
-pub async fn run(chain_name: &Option<String>, madara_flags: &Option<String>) {
-    match start_app_chain(chain_name, madara_flags).await {
+pub async fn run(chain_name: &Option<String>, madara_flags: &Vec<String>) {
+    match start_app_chain(chain_name, &madara_flags).await {
         Ok(_) => {
             log::info!("Madara setup successful");
         }
@@ -35,7 +35,7 @@ pub async fn run(chain_name: &Option<String>, madara_flags: &Option<String>) {
     }
 }
 
-async fn start_app_chain(chain_name: &Option<String>, madara_flags: &Option<String>) -> Result<(), RunError> {
+async fn start_app_chain(chain_name: &Option<String>, madara_flags: &Vec<String>) -> Result<(), RunError> {
     let app_chain: String = match chain_name {
         Some(chain_name) => chain_name.to_string(),
         None => {
@@ -58,7 +58,7 @@ async fn start_app_chain(chain_name: &Option<String>, madara_flags: &Option<Stri
     da_factory.confirm_minimum_balance(&config)?;
     da_factory.setup(&config).await?;
 
-    madara::setup_and_run_madara(config, madara_flags.as_ref().unwrap_or(&String::from("")))?;
+    madara::setup_and_run_madara(config, &madara_flags)?;
 
     Ok(())
 }

src/da/da_layers.rs

@@ -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, EnumString)]
+#[derive(Debug, Serialize, Deserialize, EnumIter, Display, Clone, EnumString, clap::ValueEnum)]
 pub enum DALayer {
     Avail,
     Ethereum,

src/main.rs

@@ -1,7 +1,9 @@
 use clap::{Parser, Subcommand};
 use log::LevelFilter;
+use madara_cli::app::config::RollupMode;
 use madara_cli::cli;
 use madara_cli::cli::explorer::ExplorerOpts;
+use madara_cli::da::da_layers::DALayer;
 
 #[derive(Parser)]
 #[command(author, version, about, long_about = None)]
@@ -15,25 +17,24 @@ enum Commands {
     /// Init a new App Chain config
     Init {
         /// App chain name
-        #[arg(short, long = "chain-name")]
+        #[clap(short, long = "chain-name")]
         name: Option<String>,
-        /// Select Sovereign
-        #[arg(short, long = "chain-mode")]
-        mode: Option<String>,
-        /// Select between Avail, Celestia, Ethereum, NoDA
-        #[arg(short, long = "da-layer")]
-        da: Option<String>,
+        /// Choose a supported Rollup Mode
+        #[clap(short, long = "chain-mode", value_enum, ignore_case = true)]
+        mode: Option<RollupMode>,
+        /// Choose a supported DA Layer
+        #[clap(short, long = "da-layer", value_enum, ignore_case = true)]
+        da: Option<DALayer>,
     },
     /// Lists all the existing App Chain configs
     List,
     /// Runs the App Chain using Madara
     Run {
         /// App chain name
-        #[arg(short, long = "chain-name")]
+        #[clap(short, long = "chain-name")]
         name: Option<String>,
         /// Additional arguments for Madara
-        #[arg(short, long = "madara-flags")]
-        flags: Option<String>,
+        madara_flags: Vec<String>,
     },
     /// Runs the L2 explorer
     Explorer(ExplorerOpts),
@@ -53,7 +54,7 @@ async fn main() {
     match &cli.command {
         Some(Commands::Init { name, mode, da }) => cli::init::init(name, mode, da).await,
         Some(Commands::List) => cli::list::list(),
-        Some(Commands::Run { name, flags }) => cli::run::run(name, flags).await,
+        Some(Commands::Run { name, madara_flags}) => cli::run::run(name, madara_flags).await,
         Some(Commands::Explorer(opts)) => cli::explorer::explorer(opts).await,
         None => log::info!("Use --help to see the complete list of available commands"),
     }

src/utils/madara.rs

@@ -34,7 +34,7 @@ pub fn clone_madara_and_build_repo(config: &AppChainConfig) -> Result<(), Madara
     Ok(())
 }
 
-pub fn setup_and_run_madara(config: AppChainConfig, flags: &String) -> Result<(), MadaraError> {
+pub fn setup_and_run_madara(config: AppChainConfig, madara_flags: &Vec<String>) -> Result<(), MadaraError> {
     let madara_path = get_madara_home()?.join("madara");
 
     let app_home = get_app_home(config.app_chain.as_str())?;
@@ -60,7 +60,7 @@ pub fn setup_and_run_madara(config: AppChainConfig, flags: &String) -> Result<()
         &base_path,
     ];
 
-    args.extend(flags.split(",").map(|flag| flag.trim()).filter(|flag| !flag.is_empty()));
+    args.extend(madara_flags.iter().map(|arg| arg.as_str()));
 
     match config.da_layer {
         DALayer::Ethereum => {