Allow to override chainstate options for regtest

common/Cargo.toml

@@ -21,7 +21,6 @@ parity-scale-codec = "3.1"
 serde = "1.0"
 sscanf = "0.2"
 static_assertions = "1.1"
-strum = { version = "0.24", features = ["derive"] }
 thiserror = "1.0"
 hex = "0.4"
 

common/src/chain/config/mod.rs

@@ -40,19 +40,7 @@ use std::time::Duration;
 const DEFAULT_MAX_FUTURE_BLOCK_TIME_OFFSET: Duration = Duration::from_secs(60 * 60);
 pub const DEFAULT_TARGET_BLOCK_SPACING: Duration = Duration::from_secs(120);
 
-#[derive(
-    Debug,
-    Copy,
-    Clone,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    strum::Display,
-    strum::EnumVariantNames,
-    strum::EnumString,
-)]
-#[strum(serialize_all = "kebab-case")]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum ChainType {
     Mainnet,
     Testnet,
@@ -279,19 +267,6 @@ mod tests {
         assert_eq!(config.chain_type(), &ChainType::Mainnet);
     }
 
-    #[test]
-    fn chain_type_names() {
-        use strum::VariantNames;
-
-        assert_eq!(&ChainType::Mainnet.to_string(), "mainnet");
-        assert_eq!(&ChainType::Testnet.to_string(), "testnet");
-
-        for chain_type_str in ChainType::VARIANTS {
-            let chain_type: ChainType = chain_type_str.parse().expect("cannot parse chain type");
-            assert_eq!(&chain_type.to_string(), chain_type_str);
-        }
-    }
-
     #[test]
     fn different_magic_bytes() {
         let config1 = Builder::new(ChainType::Regtest).build();

node/Cargo.toml

@@ -20,12 +20,12 @@ subsystem = { path = "../subsystem/" }
 anyhow = "1.0"
 clap = { version = "3.1", features = ["derive"] }
 jsonrpsee = { version = "0.14", features = ["macros"] }
-strum = "0.24"
 tokio = { version = "1.19", default-features = false }
 thiserror = "1.0"
 serde = { version = "1", features = ["derive"] }
 toml = "0.5"
 directories = "4.0"
+paste = "1.0"
 
 [dev-dependencies]
 assert_cmd = "2"

node/src/options.rs

@@ -20,9 +20,6 @@ use std::{ffi::OsString, fs, net::SocketAddr, path::PathBuf};
 use anyhow::{Context, Result};
 use clap::{Args, Parser, Subcommand};
 use directories::UserDirs;
-use strum::VariantNames;
-
-use common::chain::config::ChainType;
 
 const DATA_DIR_NAME: &str = ".mintlayer";
 const CONFIG_NAME: &str = "config.toml";
@@ -51,16 +48,13 @@ pub struct Options {
 pub enum Command {
     /// Create a configuration file.
     CreateConfig,
-    Run(RunOptions),
+    Mainnet(RunOptions),
+    Regtest(RegtestOptions),
 }
 
-/// Run the node.
+/// Run the mainnet node.
 #[derive(Args, Debug)]
 pub struct RunOptions {
-    /// Blockchain type.
-    #[clap(long, possible_values = ChainType::VARIANTS, default_value = "mainnet")]
-    pub net: ChainType,
-
     /// The number of maximum attempts to process a block.
     #[clap(long)]
     pub max_db_commit_attempts: Option<usize>,
@@ -86,6 +80,54 @@ pub struct RunOptions {
     pub rpc_addr: Option<SocketAddr>,
 }
 
+/// Run the regtest node.
+#[derive(Args, Debug)]
+pub struct RegtestOptions {
+    #[clap(flatten)]
+    pub run_options: RunOptions,
+    #[clap(flatten)]
+    pub chain_config: ChainConfigOptions,
+}
+
+#[derive(Args, Debug)]
+pub struct ChainConfigOptions {
+    /// Address prefix.
+    #[clap(long)]
+    pub chain_address_prefix: Option<String>,
+
+    /// Block reward maturity.
+    #[clap(long)]
+    pub chain_blockreward_maturity: Option<i64>,
+
+    /// The maximum future block offset in seconds.
+    #[clap(long)]
+    pub chain_max_future_block_time_offset: Option<u64>,
+
+    /// The chain version (major.minor.path).
+    #[clap(long)]
+    pub chain_version: Option<String>,
+
+    /// Target block spacing in seconds.
+    #[clap(long)]
+    pub chain_target_block_spacing: Option<u64>,
+
+    /// Coin decimals.
+    #[clap(long)]
+    pub chain_coin_decimals: Option<u8>,
+
+    /// The maximum block header size in bytes.
+    #[clap(long)]
+    pub chain_max_block_header_size: Option<usize>,
+
+    /// The maximum transactions size in block in bytes.
+    #[clap(long)]
+    pub chain_max_block_size_with_standard_txs: Option<usize>,
+
+    /// The maximum smart contracts size ib block in bytes.
+    #[clap(long)]
+    pub chain_max_block_size_with_smart_contracts: Option<usize>,
+}
+
 impl Options {
     /// Constructs an instance by parsing the given arguments.
     ///

node/src/runner.rs

@@ -15,41 +15,34 @@
 
 //! Node initialisation routine.
 
-use std::{fs, sync::Arc};
+use std::{fs, path::Path, sync::Arc, time::Duration};
 
-use anyhow::{Context, Result};
+use anyhow::{anyhow, Context, Result};
+use paste::paste;
 
 use chainstate::rpc::ChainstateRpcServer;
-use common::chain::config::ChainType;
+use common::{
+    chain::config::{Builder as ChainConfigBuilder, ChainConfig, ChainType},
+    primitives::{semver::SemVer, BlockDistance},
+};
 use logging::log;
 use p2p::rpc::P2pRpcServer;
 
 use crate::{
     config::NodeConfig,
-    options::{Command, Options},
+    options::{ChainConfigOptions, Command, Options, RunOptions},
 };
 
-#[derive(Debug, Ord, PartialOrd, PartialEq, Eq, Clone, Copy, thiserror::Error)]
-enum Error {
-    #[error("Chain type '{0}' not yet supported")]
-    UnsupportedChain(ChainType),
-}
-
 /// Initialize the node, giving caller the opportunity to add more subsystems before start.
 pub async fn initialize(
-    chain_type: ChainType,
+    chain_config: ChainConfig,
     node_config: NodeConfig,
 ) -> Result<subsystem::Manager> {
+    let chain_config = Arc::new(chain_config);
+
     // Initialize storage.
     let storage = chainstate_storage::Store::new_empty()?;
 
-    // Initialize chain configuration.
-    let chain_config = Arc::new(match chain_type {
-        ChainType::Mainnet => common::chain::config::create_mainnet(),
-        ChainType::Regtest => common::chain::config::create_regtest(),
-        chain_ty => return Err(Error::UnsupportedChain(chain_ty).into()),
-    });
-
     // INITIALIZE SUBSYSTEMS
 
     let mut manager = subsystem::Manager::new("mintlayer");
@@ -105,17 +98,87 @@ pub async fn run(options: Options) -> Result<()> {
                 .with_context(|| format!("Failed to write config to the '{path:?}' file"))?;
             Ok(())
         }
-        Command::Run(ref run_options) => {
-            let node_config = NodeConfig::read(&options.config_path(), run_options)
-                .context("Failed to initialize config")?;
-            log::trace!("Starting with the following config\n: {node_config:#?}");
-            let manager = initialize(run_options.net, node_config).await?;
-            #[allow(clippy::unit_arg)]
-            Ok(manager.main().await)
+        Command::Mainnet(ref run_options) => {
+            let chain_config = common::chain::config::create_mainnet();
+            start(&options.config_path(), run_options, chain_config).await
+        }
+        Command::Regtest(ref regtest_options) => {
+            let chain_config = regtest_chain_config(&regtest_options.chain_config)?;
+            start(
+                &options.config_path(),
+                &regtest_options.run_options,
+                chain_config,
+            )
+            .await
         }
     }
 }
 
+async fn start(
+    config_path: &Path,
+    run_options: &RunOptions,
+    chain_config: ChainConfig,
+) -> Result<()> {
+    let node_config =
+        NodeConfig::read(config_path, run_options).context("Failed to initialize config")?;
+    log::trace!("Starting with the following config\n: {node_config:#?}");
+    let manager = initialize(chain_config, node_config).await?;
+    manager.main().await;
+    Ok(())
+}
+
+fn regtest_chain_config(options: &ChainConfigOptions) -> Result<ChainConfig> {
+    let ChainConfigOptions {
+        chain_address_prefix,
+        chain_blockreward_maturity,
+        chain_max_future_block_time_offset,
+        chain_version,
+        chain_target_block_spacing,
+        chain_coin_decimals,
+        chain_max_block_header_size,
+        chain_max_block_size_with_standard_txs,
+        chain_max_block_size_with_smart_contracts,
+    } = options;
+
+    let mut builder = ChainConfigBuilder::new(ChainType::Regtest);
+
+    macro_rules! update_builder {
+        ($field: ident) => {
+            paste! {
+                if let Some(val) = [<chain_ $field>] {
+                    builder = builder.$field(val.to_owned());
+                }
+            }
+        };
+        ($field: ident, $converter: stmt) => {
+            paste! {
+                if let Some(val) = [<chain_ $field>] {
+                    builder = builder.$field($converter(val.to_owned()));
+                }
+            }
+        };
+        ($field: ident, $converter: stmt, map_err) => {
+            paste! {
+                if let Some(val) = [<chain_ $field>] {
+                    builder = builder.$field($converter(val.to_owned()).map_err(|e| anyhow!(e))?);
+                }
+            }
+        };
+    }
+
+    update_builder!(address_prefix);
+    update_builder!(blockreward_maturity, BlockDistance::new);
+    update_builder!(max_future_block_time_offset, Duration::from_secs);
+    update_builder!(version, SemVer::try_from, map_err);
+    update_builder!(target_block_spacing, Duration::from_secs);
+    update_builder!(coin_decimals);
+    update_builder!(max_block_header_size);
+    update_builder!(max_block_size_with_standard_txs);
+    update_builder!(max_block_size_with_smart_contracts);
+
+    Ok(builder.build())
+}
+
 #[rpc::rpc(server, namespace = "node")]
 trait NodeRpc {
     /// Order the node to shutdown

node/tests/cli.rs

@@ -19,7 +19,6 @@ use assert_cmd::Command;
 use directories::UserDirs;
 use tempdir::TempDir;
 
-use common::chain::config::ChainType;
 use node::{NodeConfig, RunOptions};
 
 const BIN_NAME: &str = env!("CARGO_BIN_EXE_node");
@@ -90,7 +89,6 @@ fn read_config_override_values() {
     let rpc_addr = SocketAddr::from_str("127.0.0.1:5432").unwrap();
 
     let options = RunOptions {
-        net: ChainType::Mainnet,
         max_db_commit_attempts: Some(max_db_commit_attempts),
         max_orphan_blocks: Some(max_orphan_blocks),
         p2p_addr: Some(p2p_addr.into()),
@@ -162,7 +160,6 @@ fn custom_config_path_and_data_dir() {
 
 fn default_run_options() -> RunOptions {
     RunOptions {
-        net: ChainType::Mainnet,
         max_db_commit_attempts: None,
         max_orphan_blocks: None,
         p2p_addr: None,

test/functional/test_framework/test_node.py

@@ -107,8 +107,7 @@ def __init__(self, i, datadir, *, chain, rpchost, timewait, timeout_factor, bitc
         self.args = [
             self.binary,
             "--datadir={}".format(datadir_path),
-            "run",
-            "--net=regtest",
+            "regtest",
             "--rpc-addr={}".format(rpc_addr),
             "--p2p-addr={}".format(p2p_addr),
             #"-X",