deeper defaults

components/clarinet-cli/src/devnet/start.rs

@@ -21,6 +21,7 @@ pub fn start(
     deployment: DeploymentSpecification,
     log_tx: Option<Sender<LogData>>,
     display_dashboard: bool,
+    default_settings: bool,
 ) -> Result<
     (
         Option<mpsc::Receiver<DevnetEvent>>,
@@ -29,62 +30,73 @@ pub fn start(
     ),
     String,
 > {
-    let hooks = match load_chainhooks(
-        &devnet.manifest.location,
-        &(BitcoinNetwork::Regtest, StacksNetwork::Devnet),
-    ) {
-        Ok(hooks) => hooks,
-        Err(e) => {
-            println!("{}", e);
-            std::process::exit(1);
-        }
+    let mut hooks = if default_settings {
+        None
+    } else {
+        Some(
+            match load_chainhooks(
+                &devnet.manifest.location,
+                &(BitcoinNetwork::Regtest, StacksNetwork::Devnet),
+            ) {
+                Ok(hooks) => hooks,
+                Err(e) => {
+                    println!("{}", e);
+                    std::process::exit(1);
+                }
+            },
+        )
     };
+    println!("after hooks");
 
-    let working_dir = devnet
-        .network_config
-        .as_ref()
-        .and_then(|c| c.devnet.as_ref())
-        .map(|d| d.working_dir.to_string())
-        .ok_or("unable to read settings/Devnet.toml")?;
-    fs::create_dir_all(&working_dir)
-        .map_err(|_| format!("unable to create dir {}", working_dir))?;
-    let mut log_path = PathBuf::from_str(&working_dir)
-        .map_err(|e| format!("unable to working_dir {}\n{}", working_dir, e))?;
-    log_path.push("devnet.log");
+    let (logger, working_dir) = if !default_settings {
+        let working_dir = devnet
+            .network_config
+            .as_ref()
+            .and_then(|c| c.devnet.as_ref())
+            .map(|d| d.working_dir.to_string())
+            .ok_or("unable to read settings/Devnet.toml")?;
+        fs::create_dir_all(&working_dir)
+            .map_err(|_| format!("unable to create dir {}", working_dir))?;
+        let mut log_path = PathBuf::from_str(&working_dir)
+            .map_err(|e| format!("unable to working_dir {}\n{}", working_dir, e))?;
+        log_path.push("devnet.log");
+        let file = OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .open(log_path)
+            .map_err(|e| format!("unable to create log file {}", e))?;
 
-    let file = OpenOptions::new()
-        .create(true)
-        .write(true)
-        .truncate(true)
-        .open(log_path)
-        .map_err(|e| format!("unable to create log file {}", e))?;
-
-    let decorator = slog_term::PlainDecorator::new(file);
-    let drain = slog_term::FullFormat::new(decorator).build().fuse();
-    let drain = slog_async::Async::new(drain).build().fuse();
-    let logger = slog::Logger::root(drain, o!());
+        let decorator = slog_term::PlainDecorator::new(file);
+        let drain = slog_term::FullFormat::new(decorator).build().fuse();
+        let drain = slog_async::Async::new(drain).build().fuse();
+        (Some(slog::Logger::root(drain, o!())), Some(working_dir))
+    } else {
+        (None, None)
+    };
 
     let ctx = Context {
-        logger: Some(logger),
+        logger,
         tracer: false,
     };
-
     let (orchestrator_terminated_tx, orchestrator_terminated_rx) = channel();
     let res = hiro_system_kit::nestable_block_on(do_run_local_devnet(
         devnet,
         deployment,
-        &mut Some(hooks),
+        &mut hooks,
         log_tx,
         display_dashboard,
         ctx,
         orchestrator_terminated_tx,
         Some(orchestrator_terminated_rx),
     ));
-    println!(
-        "{} logs and chainstate available at location {}",
-        yellow!("\nterminating devnet network:"),
-        working_dir
-    );
+    if !default_settings {
+        println!(
+            "{} logs and chainstate available at location {}",
+            yellow!("\nterminating devnet network:"),
+            working_dir.unwrap()
+        );
+    }
 
     res
 }

components/clarinet-cli/src/frontend/cli.rs

@@ -40,7 +40,6 @@ use stacks_network::{self, DevnetOrchestrator};
 use std::collections::HashMap;
 use std::fs::{self, File};
 use std::io::prelude::*;
-use std::path::PathBuf;
 use std::{env, process};
 use toml;
 
@@ -1791,7 +1790,6 @@ fn display_deploy_hint() {
 fn devnet_start(cmd: DevnetStart, global_settings: GlobalSettings) {
     let manifest = if cmd.default_settings {
         let project_root_location = FileLocation::from_path(
-            // PathBuf::from(".");
             std::env::current_dir().expect("Failed to get current directory"),
         );
         println!("Using default project manifest");
@@ -1816,6 +1814,8 @@ fn devnet_start(cmd: DevnetStart, global_settings: GlobalSettings) {
                 let deployment: ConfigurationPackage = serde_json::from_reader(package_file)
                     .expect("error while reading deployment specification");
                 Some(Ok(deployment.deployment_plan))
+            } else if cmd.default_settings {
+                Some(Ok(DeploymentSpecification::default()))
             } else {
                 load_deployment_if_exists(
                     &manifest,
@@ -1862,6 +1862,7 @@ fn devnet_start(cmd: DevnetStart, global_settings: GlobalSettings) {
             }
         }
         Some(deployment_plan_path) => {
+            println!("before get absolute");
             let deployment_path = get_absolute_deployment_path(&manifest, &deployment_plan_path)
                 .expect("unable to retrieve deployment");
             load_deployment(&manifest, &deployment_path)
@@ -1876,13 +1877,14 @@ fn devnet_start(cmd: DevnetStart, global_settings: GlobalSettings) {
         }
     };
 
-    let orchestrator = match DevnetOrchestrator::new(manifest, None, None, true) {
-        Ok(orchestrator) => orchestrator,
-        Err(e) => {
-            eprintln!("{}", format_err!(e));
-            process::exit(1);
-        }
-    };
+    let orchestrator =
+        match DevnetOrchestrator::new(manifest, Some(NetworkManifest::default()), None, true) {
+            Ok(orchestrator) => orchestrator,
+            Err(e) => {
+                eprintln!("{}", format_err!(e));
+                process::exit(1);
+            }
+        };
 
     if orchestrator.manifest.project.telemetry {
         #[cfg(feature = "telemetry")]
@@ -1893,7 +1895,14 @@ fn devnet_start(cmd: DevnetStart, global_settings: GlobalSettings) {
             ),
         ));
     }
-    match start(orchestrator, deployment, None, !cmd.no_dashboard) {
+    println!("before start");
+    match start(
+        orchestrator,
+        deployment,
+        None,
+        !cmd.no_dashboard,
+        cmd.default_settings,
+    ) {
         Err(e) => {
             eprintln!("{}", format_err!(e));
             process::exit(1);

components/clarinet-deployments/src/types.rs

@@ -921,6 +921,21 @@ pub struct DeploymentSpecification {
     pub contracts: BTreeMap<QualifiedContractIdentifier, (String, FileLocation)>,
 }
 
+impl Default for DeploymentSpecification {
+    fn default() -> Self {
+        DeploymentSpecification {
+            id: 1,
+            name: "Default".to_string(),
+            network: StacksNetwork::Devnet,
+            stacks_node: None,
+            bitcoin_node: None,
+            genesis: None,
+            plan: TransactionPlanSpecification { batches: vec![] },
+            contracts: BTreeMap::new(),
+        }
+    }
+}
+
 pub mod contracts_serde {
     use base64::{engine::general_purpose::STANDARD as b64, Engine as _};
     use clarinet_files::FileLocation;

components/clarinet-files/src/network_manifest.rs

@@ -183,6 +183,22 @@ pub struct NetworkManifest {
     pub devnet: Option<DevnetConfig>,
 }
 
+impl Default for NetworkManifest {
+    fn default() -> Self {
+        Self {
+            network: NetworkConfig {
+                name: "Default".to_string(),
+                stacks_node_rpc_address: None,
+                bitcoin_node_rpc_address: None,
+                deployment_fee_rate: 1,
+                sats_per_bytes: 1,
+            },
+            accounts: BTreeMap::new(),
+            devnet: None, // Some(DevnetConfig::default()), // this is not really optional
+        }
+    }
+}
+
 pub mod accounts_serde {
     use std::collections::BTreeMap;
 

components/stacks-network/src/orchestrator.rs

@@ -140,7 +140,7 @@ impl DevnetOrchestrator {
                     .map_err(|e| format!("unable to connect to docker: {:?}", e))?;
                     Some(client)
                 }
-                None => unreachable!(),
+                None => None,
             },
             false => None,
         };