cleanup: overwrite prev config with cli options

Author: vid277

.gitignore

@@ -61,4 +61,7 @@ Cargo.lock
 .env
 visuals/nodes
 visuals/manim/__pycache__
-visuals/manim/media/
+visuals/manim/media/
+
+tests/config.json
+tests/config.toml

bin/cli/src/main.rs

@@ -138,19 +138,19 @@ enum Commands {
         key_file_path: Option<String>,
         #[arg(short, long)]
         config_file_path: Option<String>,
-        #[arg(short, long)]
+        #[arg(short = 'p', long)]
         grpc_port: Option<u16>,
         #[arg(short = 'u', long)]
         libp2p_udp_port: Option<u16>,
-        #[arg(short, long)]
+        #[arg(short = 't', long)]
         libp2p_tcp_port: Option<u16>,
         #[arg(short, long)]
         database_directory: Option<String>,
         #[arg(short = 'o', long)]
         log_file: Option<String>,
         #[arg(short = 'n', long)]
         max_signers: Option<u16>,
-        #[arg(short = 't', long)]
+        #[arg(short = 'm', long)]
         min_signers: Option<u16>,
     },
     Spend {
@@ -201,7 +201,7 @@ async fn main() -> Result<(), CliError> {
             max_signers,
             min_signers,
         } => {
-            start_node_cli(
+            start_node_cli(StartNodeConfigParams {
                 key_file_path,
                 config_file_path,
                 grpc_port,
@@ -211,7 +211,7 @@ async fn main() -> Result<(), CliError> {
                 log_file,
                 max_signers,
                 min_signers,
-            )
+            })
             .await
             .map_err(|e| CliError::NodeError(e.to_string()))?;
         }
@@ -295,6 +295,10 @@ fn setup_config(output_dir: Option<String>, file_name: Option<String>) -> Result
     .map_err(|e| KeygenError::KeyFileNotFound(e.to_string()))?;
 
     config.set_key_data(key_data);
+    config.set_grpc_port(50051);
+    config.set_libp2p_udp_port(0);
+    config.set_libp2p_tcp_port(0);
+    config.set_database_directory(PathBuf::from("nodedb.db"));
 
     config
         .save_to_file()
@@ -310,7 +314,7 @@ fn setup_config(output_dir: Option<String>, file_name: Option<String>) -> Result
     Ok(())
 }
 
-async fn start_node_cli(
+struct StartNodeConfigParams {
     key_file_path: Option<String>,
     config_file_path: Option<String>,
     grpc_port: Option<u16>,
@@ -320,23 +324,41 @@ async fn start_node_cli(
     log_file: Option<String>,
     max_signers: Option<u16>,
     min_signers: Option<u16>,
-) -> Result<(), NodeError> {
-    let config = match get_config(key_file_path.clone(), config_file_path.clone()) {
+}
+
+async fn start_node_cli(params: StartNodeConfigParams) -> Result<(), NodeError> {
+    let mut config = match get_config(
+        params.key_file_path.clone(),
+        params.config_file_path.clone(),
+    ) {
         Ok(config) => config,
         Err(e) => {
             return Err(NodeError::Error(format!("Failed to get config: {}", e)));
         }
     };
 
+    if let Some(port) = params.grpc_port {
+        config.set_grpc_port(port);
+    }
+
+    if let Some(port) = params.libp2p_udp_port {
+        config.set_libp2p_udp_port(port);
+    }
+
+    if let Some(port) = params.libp2p_tcp_port {
+        config.set_libp2p_tcp_port(port);
+    }
+
+    if let Some(dir) = params.database_directory {
+        config.set_database_directory(PathBuf::from(dir));
+    }
+
     start_node(
-        max_signers,
-        min_signers,
+        params.max_signers,
+        params.min_signers,
         config,
-        grpc_port,
-        log_file.map(PathBuf::from),
-        libp2p_udp_port,
-        libp2p_tcp_port,
-        database_directory.map(PathBuf::from),
+        params.grpc_port,
+        params.log_file.map(PathBuf::from),
     )
     .await?;
     Ok(())

crates/node/src/handlers/dkg/utils.rs

@@ -140,7 +140,7 @@ impl DkgState {
 
         node.db.insert_block(genesis_block.to_block())?;
 
-        node.config.save_to_file()?;
+        node.config.save_to_keys_file()?;
         Ok(())
     }
 }

crates/node/src/lib.rs

@@ -68,13 +68,13 @@ pub struct NodeConfig {
     pub dkg_keys: Option<DkgKeys>,
     pub log_file_path: Option<PathBuf>,
     #[serde(skip)]
-    key_file_path: PathBuf,
+    pub key_file_path: PathBuf,
     #[serde(skip)]
-    config_file_path: PathBuf,
-    database_directory: Option<PathBuf>,
-    grpc_port: Option<u16>,
-    libp2p_udp_port: Option<u16>,
-    libp2p_tcp_port: Option<u16>,
+    pub config_file_path: PathBuf,
+    pub database_directory: PathBuf,
+    pub grpc_port: u16,
+    pub libp2p_udp_port: u16,
+    pub libp2p_tcp_port: u16,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -88,10 +88,10 @@ pub struct ConfigStore {
     allowed_peers: Vec<PeerData>,
     log_file_path: Option<PathBuf>,
     key_file_path: PathBuf,
-    database_directory: Option<PathBuf>,
-    grpc_port: Option<u16>,
-    libp2p_udp_port: Option<u16>,
-    libp2p_tcp_port: Option<u16>,
+    database_directory: PathBuf,
+    grpc_port: u16,
+    libp2p_udp_port: u16,
+    libp2p_tcp_port: u16,
 }
 
 impl NodeConfig {
@@ -156,11 +156,26 @@ impl NodeConfig {
             log_file_path,
             key_file_path,
             config_file_path,
-            database_directory: None,
-            grpc_port: None,
-            libp2p_udp_port: None,
-            libp2p_tcp_port: None,
-            })
+            database_directory: PathBuf::from("nodedb.db"),
+            grpc_port: 50051,
+            libp2p_udp_port: 0,
+            libp2p_tcp_port: 0,
+        })
+    }
+
+    pub fn save_to_keys_file(&self) -> Result<(), NodeError> {
+        let key_store = KeyStore {
+            key_data: self.key_data.clone(),
+            dkg_keys: self.dkg_keys.clone(),
+        };
+
+        let key_info_str = serde_json::to_string_pretty(&key_store)
+            .map_err(|e| NodeError::Error(format!("Failed to serialize key data: {}", e)))?;
+
+        fs::write(&self.key_file_path, key_info_str)
+            .map_err(|e| NodeError::Error(format!("Failed to write key data: {}", e)))?;
+
+        Ok(())
     }
 
     pub fn save_to_file(&self) -> Result<(), NodeError> {
@@ -180,9 +195,9 @@ impl NodeConfig {
             log_file_path: self.log_file_path.clone(),
             key_file_path: self.key_file_path.clone(),
             database_directory: self.database_directory.clone(),
-            grpc_port: self.grpc_port.clone(),
-            libp2p_udp_port: self.libp2p_udp_port.clone(),
-            libp2p_tcp_port: self.libp2p_tcp_port.clone(),
+            grpc_port: self.grpc_port,
+            libp2p_udp_port: self.libp2p_udp_port,
+            libp2p_tcp_port: self.libp2p_tcp_port,
         };
 
         let config_str: String = serde_yaml::to_string(&config_store).unwrap();
@@ -200,6 +215,22 @@ impl NodeConfig {
     pub fn set_key_data(&mut self, key_data: KeyData) {
         self.key_data = key_data;
     }
+
+    pub fn set_grpc_port(&mut self, port: u16) {
+        self.grpc_port = port;
+    }
+
+    pub fn set_libp2p_udp_port(&mut self, port: u16) {
+        self.libp2p_udp_port = port;
+    }
+
+    pub fn set_libp2p_tcp_port(&mut self, port: u16) {
+        self.libp2p_tcp_port = port;
+    }
+
+    pub fn set_database_directory(&mut self, dir: PathBuf) {
+        self.database_directory = dir;
+    }
 }
 
 pub struct NodeState<N: Network, D: Db, O: Oracle> {

crates/node/src/start_node.rs

@@ -19,16 +19,12 @@ pub async fn start_node(
     config: NodeConfig,
     grpc_port: Option<u16>,
     log_file: Option<PathBuf>,
-    libp2p_udp_port: Option<u16>,
-    libp2p_tcp_port: Option<u16>,
-    database_directory: Option<PathBuf>,
 ) -> Result<(), NodeError> {
     // Initialize logging
     let env_filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
+
     let config_database_path = config.database_directory.clone();
-    let config_grpc_port = config.grpc_port.clone();
-    let config_libp2p_udp_port = config.libp2p_tcp_port.clone();
-    let config_libp2p_tcp_port = config.libp2p_tcp_port.clone();
+    let config_grpc_port = config.grpc_port;
 
     let registry = tracing_subscriber::registry().with(env_filter);
 
@@ -91,8 +87,8 @@ pub async fn start_node(
 
     let (network_handle, mut swarm) = build_swarm(
         keypair.clone(),
-        libp2p_udp_port.or(config_libp2p_udp_port),
-        libp2p_tcp_port.or(config_libp2p_tcp_port),
+        config.libp2p_udp_port,
+        config.libp2p_tcp_port,
         allowed_peers.clone(),
     )
     .expect("Failed to build swarm");
@@ -105,11 +101,7 @@ pub async fn start_node(
         min_signers,
         max_signers,
         config,
-        RocksDb::new(
-            database_directory.or(config_database_path).unwrap_or(PathBuf::from("nodedb.db"))
-                .to_str()
-                .unwrap(),
-        ),
+        RocksDb::new(config_database_path.to_str().unwrap()),
         swarm.network_events.clone(),
         deposit_intent_tx,
         transaction_rx,
@@ -124,7 +116,7 @@ pub async fn start_node(
     });
 
     let grpc_handle = tokio::spawn(async move {
-        let addr = format!("0.0.0.0:{}", grpc_port.or(config_grpc_port).unwrap_or(50051))
+        let addr = format!("0.0.0.0:{}", grpc_port.unwrap_or(config_grpc_port))
             .parse()
             .unwrap();
 

crates/node/src/utils/swarm_manager.rs

@@ -402,8 +402,8 @@ impl SwarmManager {
 
 pub fn build_swarm(
     keypair: Keypair,
-    libp2p_udp_port: Option<u16>,
-    libp2p_tcp_port: Option<u16>,
+    libp2p_udp_port: u16,
+    libp2p_tcp_port: u16,
     peer_data: Vec<PeerData>,
 ) -> Result<(NetworkHandle, SwarmManager), NodeError> {
     let mut swarm = libp2p::SwarmBuilder::with_existing_identity(keypair)
@@ -464,15 +464,15 @@ pub fn build_swarm(
 
     swarm
         .listen_on(
-            format!("/ip4/0.0.0.0/udp/{}/quic-v1", libp2p_udp_port.unwrap_or(0))
+            format!("/ip4/0.0.0.0/udp/{}/quic-v1", libp2p_udp_port)
                 .parse()
                 .expect("Failed to deserialize message"),
         )
         .map_err(|e| NodeError::Error(format!("Failed to listen on quic {}", e)))?;
 
     swarm
         .listen_on(
-            format!("/ip4/0.0.0.0/tcp/{}", libp2p_tcp_port.unwrap_or(0))
+            format!("/ip4/0.0.0.0/tcp/{}", libp2p_tcp_port)
                 .parse()
                 .expect("Failed to deserialize message"),
         )

tests/config.json

@@ -19,7 +19,11 @@ mod config_test {
                     "salt_b64": "TnErEFlx9F1BeU8mJcFzKQ",
                     "iv_b64": "hybTge0qoPaxNUhP"
                 }
-            }
+            },
+            "database_directory": "nodedb.db",
+            "grpc_port": 50051,
+            "libp2p_udp_port": 0,
+            "libp2p_tcp_port": 0
         }"#;
 
         let config: NodeConfig = serde_json::from_str(json_str).expect("Failed to deserialize");
@@ -29,5 +33,12 @@ mod config_test {
             "12D3KooWQDHzW448RmDoUz1KbMfuD4XqeojRJDsxqUZSEYo7FSUz"
         );
         assert!(config.dkg_keys.is_none());
+        assert_eq!(
+            config.database_directory,
+            std::path::PathBuf::from("nodedb.db")
+        );
+        assert_eq!(config.grpc_port, 50051);
+        assert_eq!(config.libp2p_udp_port, 0);
+        assert_eq!(config.libp2p_tcp_port, 0);
     }
 }