switched from custom config parsing to toml

Cargo.toml

@@ -65,7 +65,9 @@ http-types = "2.9.0"
 async-h1 = "2.3.0"
 async-native-tls = "0.3.3"
 toml = "0.5.8"
-serde = "1.0.126"
+
+# serde
+serde = { version = "1.0.126", features = ["derive"]}
 
 # zmq
 zeromq = { git="https://github.com/zeromq/zmq.rs", default-features = false, features = ["async-std-runtime", "all-transport"] }

src/bin/darkfid.rs

@@ -1,5 +1,5 @@
 use drk::blockchain::{rocks::columns, Rocks, RocksColumn};
-use drk::cli::{DarkfidCliConfig, DarkfidCli, ClientCliConfig};
+use drk::cli::{DarkfidCli, DarkfidCliConfig};
 use drk::crypto::{
     load_params,
     merkle::{CommitmentTree, IncrementalWitness},
@@ -11,10 +11,16 @@ use drk::crypto::{
 use drk::serial::Decodable;
 use drk::service::{GatewayClient, GatewaySlabsSubscriber};
 use drk::state::{state_transition, ProgramState, StateUpdate};
+use drk::util;
 use drk::util::join_config_path;
 use drk::wallet::{WalletDB, WalletPtr};
 use drk::{tx, Result};
 use log::*;
+use std::fs;
+use std::str;
+//use std::fs::File;
+use std::fs::OpenOptions;
+use toml;
 //use drk::rpc::
 use drk::rpc::adapter::RpcAdapter;
 use drk::rpc::jsonserver;
@@ -28,6 +34,7 @@ use rand::rngs::OsRng;
 use rusqlite::Connection;
 
 use async_std::sync::Arc;
+use std::io::Read;
 use std::net::SocketAddr;
 use std::path::Path;
 use std::path::PathBuf;
@@ -151,10 +158,7 @@ pub async fn subscribe(gateway_slabs_sub: GatewaySlabsSubscriber, mut state: Sta
     }
 }
 
-async fn start(
-    executor: Arc<Executor<'_>>,
-    config: Arc<DarkfidCliConfig>,
-) -> Result<()> {
+async fn start(executor: Arc<Executor<'_>>, config: Arc<&DarkfidCliConfig>) -> Result<()> {
     let connect_addr: SocketAddr = config.connect_url.parse()?;
     let sub_addr: SocketAddr = config.subscriber_url.parse()?;
     let database_path = config.database_path.clone();
@@ -224,18 +228,48 @@ async fn start(
     Ok(())
 }
 
+fn set_default() -> Result<DarkfidCliConfig> {
+    let config_file = DarkfidCliConfig {
+        connect_url: String::from("127.0.0.1:3333"),
+        subscriber_url: String::from("127.0.0.1:4444"),
+        rpc_url: String::from("127.0.0.1:8000"),
+        database_path: String::from("database_client.db"),
+        log_path: String::from("/tmp/darkfid_service_daemon.log"),
+        password: String::from(""),
+    };
+    Ok(config_file)
+}
+
 fn main() -> Result<()> {
     use simplelog::*;
 
-    let mut config = DarkfidCliConfig::load(PathBuf::from("darkfid_config"))?;
-    let options = Arc::new(DarkfidCli::load(&mut config)?);
+    let options = Arc::new(DarkfidCli::load()?);
+    let config_path = PathBuf::from("darkfid.toml");
+    let path = util::join_config_path(&config_path).unwrap();
 
-    if options.change_config {
-        config.save(PathBuf::from("darkfid_config"))?;
-        return Ok(());
+    let mut file = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(true)
+        .open(&path)?;
+
+    let mut buffer: Vec<u8> = vec![];
+    file.read_to_end(&mut buffer)?;
+
+    if buffer.is_empty() {
+        // set the default setting
+        let config_file = set_default()?;
+        let config_file = toml::to_string(&config_file)?;
+        fs::write(&path, &config_file)?;
     }
 
-    let config = Arc::new(config);
+    // reload the config
+    let toml = fs::read(&path)?;
+    let str_buff = str::from_utf8(&toml)?;
+
+    // read from config file
+    let config: DarkfidCliConfig = toml::from_str(str_buff)?;
+    let config_pointer = Arc::new(&config);
 
     let ex = Arc::new(Executor::new());
     let (signal, shutdown) = async_channel::unbounded::<()>();
@@ -267,7 +301,7 @@ fn main() -> Result<()> {
         // Run the main future on the current thread.
         .finish(|| {
             smol::future::block_on(async move {
-                start(ex2, config).await?;
+                start(ex2, config_pointer).await?;
                 drop(signal);
                 Ok::<(), drk::Error>(())
             })

src/bin/drk.rs

@@ -1,11 +1,15 @@
-use drk::cli::{ClientCliConfig, DrkCli, DrkCliConfig};
+use drk::cli::{DrkCli, DrkCliConfig};
+use drk::util;
 use drk::Result;
-
 use log::*;
+use std::fs::OpenOptions;
+use std::io::Read;
+use std::str;
+use toml;
 
 use async_std::sync::Arc;
 use std::collections::HashMap;
-use std::path::PathBuf;
+use std::{fs, path::PathBuf};
 
 type Payload = HashMap<String, String>;
 
@@ -74,7 +78,7 @@ impl Drk {
     }
 }
 
-async fn start(config: Arc<DrkCliConfig>, options: Arc<DrkCli>) -> Result<()> {
+async fn start(config: Arc<&DrkCliConfig>, options: Arc<DrkCli>) -> Result<()> {
     let url = config.rpc_url.clone();
 
     let mut client = Drk::new(url);
@@ -86,7 +90,7 @@ async fn start(config: Arc<DrkCliConfig>, options: Arc<DrkCli>) -> Result<()> {
     if options.wallet {
         client.create_wallet().await?;
     }
-    
+
     if options.key {
         client.key_gen().await?;
     }
@@ -106,18 +110,43 @@ async fn start(config: Arc<DrkCliConfig>, options: Arc<DrkCli>) -> Result<()> {
     Ok(())
 }
 
+fn set_default() -> Result<DrkCliConfig> {
+    let config_file = DrkCliConfig {
+        rpc_url: String::from("127.0.0.1:8000"),
+        log_path: String::from("/tmp/drk_cli.log"),
+    };
+    Ok(config_file)
+}
 fn main() -> Result<()> {
     use simplelog::*;
 
-    let mut config = DrkCliConfig::load(PathBuf::from("drk_config"))?;
-    let options = Arc::new(DrkCli::load(&mut config)?);
+    let options = Arc::new(DrkCli::load()?);
 
-    if options.change_config {
-        config.save(PathBuf::from("drk_config"))?;
-        return Ok(());
+    let config_path = PathBuf::from("drk.toml");
+    let path = util::join_config_path(&config_path).unwrap();
+
+    let mut file = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(true)
+        .open(&path)?;
+
+    let mut buffer: Vec<u8> = vec![];
+    file.read_to_end(&mut buffer)?;
+    if buffer.is_empty() {
+        // set the default setting
+        let config_file = set_default()?;
+        let config_file = toml::to_string(&config_file)?;
+        fs::write(&path, &config_file)?;
     }
 
-    let config = Arc::new(config);
+    // reload the config
+    let toml = fs::read(&path)?;
+    let str_buff = str::from_utf8(&toml)?;
+
+    // read from config file
+    let config: DrkCliConfig = toml::from_str(str_buff)?;
+    let config_pointer = Arc::new(&config);
 
     let logger_config = ConfigBuilder::new().set_time_format_str("%T%.6f").build();
 
@@ -138,7 +167,7 @@ fn main() -> Result<()> {
     ])
     .unwrap();
 
-    futures::executor::block_on(start(config, options))?;
+    futures::executor::block_on(start(config_pointer, options))?;
 
     Ok(())
 }

src/cli/client_cli/cli_config.rs

@@ -1,135 +1,169 @@
-use crate::serial::{deserialize, serialize, Decodable, Encodable};
-use crate::util::join_config_path;
-use crate::Result;
-use log::*;
-
-use std::{fs::OpenOptions, io::prelude::*, path::PathBuf};
-
-pub trait ClientCliConfig: Encodable + Decodable + Default {
-    fn load(path: PathBuf) -> Result<Self> {
-        let path = join_config_path(&path)?;
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(path)?;
-
-        let mut buffer: Vec<u8> = vec![];
-        file.read_to_end(&mut buffer)?;
-        if !buffer.is_empty() {
-            let config: Self = deserialize(&buffer)?;
-            Ok(config)
-        } else {
-            Ok(Self::default())
-        }
-    }
-    fn save(&self, path: PathBuf) -> Result<()> {
-        let path = join_config_path(&path)?;
-        let mut file = OpenOptions::new().write(true).create(true).open(&path)?;
-        let serialized = serialize(self);
-        file.write_all(&serialized)?;
-        Ok(())
-    }
-}
+//use crate::serial::{deserialize, serialize, Decodable, Encodable};
+//use toml::{map::Map, Value};
+//use crate::util::join_config_path;
+//use crate::Result;
+use serde::{Deserialize, Serialize};
+//use log::*;
+
+//use std::{fs::OpenOptions, io::prelude::*, path::PathBuf};
+
+//pub trait ClientCliConfig<'a>: Default + Deserialize<'a> {
+//    fn load(path: PathBuf) -> Result<Self> {
+//        let path = join_config_path(&path)?;
+//        let mut file = OpenOptions::new()
+//            .read(true)
+//            .write(true)
+//            .create(true)
+//            .open(path)?;
+//
+//        //let mut toml_map = Map::new();
+//        let mut buffer = String::new();
+//        file.read_to_string(&mut buffer)?;
+//        //let buffer: &'static str = buffer;
+//
+//        //let tomlstring = toml::to_string(&file).expect("Could not encode TTOML value");
+//        if !buffer.is_empty() {
+//            let config: Self = toml::from_str(&buffer)?;
+//            //let config = toml::to_string(&buffer).unwrap();
+//            //let config: Self = deserialize(&buffer)?;
+//            //Ok(config)
+//            Ok(config)
+//        } else {
+//            Ok(Self::default())
+//        }
+//    }
+//    fn save(&self, path: PathBuf) -> Result<()> {
+//        let path = join_config_path(&path)?;
+//        let mut file = OpenOptions::new().write(true).create(true).open(&path)?;
+//        //let serialized = serialize(self);
+//        //file.write_all(&serialized)?;
+//        Ok(())
+//    }
+//}
 
-impl ClientCliConfig for DrkCliConfig {} 
-impl ClientCliConfig for DarkfidCliConfig {} 
+//impl ClientCliConfig<'_> for DrkCliConfig {}
+//impl ClientCliConfig<'_> for DarkfidCliConfig {}
 
+//#[derive(Serialize, Default, Deserialize, Debug)]
+//pub struct Configs {
+//    pub drk: DrkCliConfig,
+//    pub darkfid: DarkfidCliConfig,
+//}
+
+#[derive(Serialize, Default, Deserialize, Debug)]
 pub struct DrkCliConfig {
+    #[serde(rename = "RPC URL")]
     pub rpc_url: String,
+
+    #[serde(rename = "Log path")]
     pub log_path: String,
 }
 
+#[derive(Serialize, Default, Deserialize, Debug)]
 pub struct DarkfidCliConfig {
+    #[serde(rename = "Connect URL")]
     pub connect_url: String,
+
+    #[serde(rename = "Subscriber URL")]
     pub subscriber_url: String,
+
+    #[serde(rename = "RPC URL")]
     pub rpc_url: String,
-    pub database_path: String,
-    pub log_path: String,
-    pub password: String,
-}
 
-impl Default for DrkCliConfig {
-    fn default() -> Self {
-        let rpc_url = String::from("http://127.0.0.1:8000");
-        let log_path = String::from("/tmp/drk_cli.log");
-        Self {
-            rpc_url,
-            log_path,
-        }
-    }
-}
+    #[serde(rename = "Database path")]
+    pub database_path: String,
 
-impl Encodable for DarkfidCliConfig {
-    fn encode<S: std::io::Write>(&self, mut s: S) -> Result<usize> {
-        let mut len = 0;
-        len += self.connect_url.encode(&mut s)?;
-        len += self.subscriber_url.encode(&mut s)?;
-        len += self.rpc_url.encode(&mut s)?;
-        len += self.database_path.encode(&mut s)?;
-        len += self.log_path.encode(&mut s)?;
-        len += self.password.encode(&mut s)?;
-        Ok(len)
-    }
-}
+    #[serde(rename = "Log path")]
+    pub log_path: String,
 
-impl Decodable for DarkfidCliConfig {
-    fn decode<D: std::io::Read>(mut d: D) -> Result<Self> {
-        Ok(Self {
-            connect_url: Decodable::decode(&mut d)?,
-            subscriber_url: Decodable::decode(&mut d)?,
-            rpc_url: Decodable::decode(&mut d)?,
-            database_path: Decodable::decode(&mut d)?,
-            log_path: Decodable::decode(&mut d)?,
-            password: Decodable::decode(&mut d)?,
-        })
-    }
+    #[serde(rename = "Password")]
+    pub password: String,
 }
 
+//impl Default for DrkCliConfig {
+//    // default toml file
+//    fn default() -> Self {
+//        let rpc_url = String::from("http://127.0.0.1:8000");
+//        let log_path = String::from("/tmp/drk_cli.log");
+//        Self {
+//            rpc_url,
+//            log_path,
+//        }
+//    }
+//}
 
-impl Default for DarkfidCliConfig {
-    fn default() -> Self {
-        let connect_url = String::from("127.0.0.1:3333");
-        let subscriber_url = String::from("127.0.0.1:4444");
-        let rpc_url = String::from("127.0.0.1:8000");
-
-        let database_path = String::from("database_client.db");
-        let database_path = join_config_path(&PathBuf::from(database_path))
-            .expect("error during join database_path to config path");
-        let database_path = String::from(
-            database_path
-                .to_str()
-                .expect("error convert Path to String"),
-        );
-        let log_path = String::from("/tmp/darkfid_service_daemon.log");
-        
-        let password = String::new();
-        Self {
-            connect_url,
-            subscriber_url,
-            rpc_url,
-            database_path,
-            log_path,
-            password,
-        }
-    }
-}
+//impl Encodable for DarkfidCliConfig {
+//    fn encode<S: std::io::Write>(&self, mut s: S) -> Result<usize> {
+//        let mut len = 0;
+//        len += self.connect_url.encode(&mut s)?;
+//        len += self.subscriber_url.encode(&mut s)?;
+//        len += self.rpc_url.encode(&mut s)?;
+//        len += self.database_path.encode(&mut s)?;
+//        len += self.log_path.encode(&mut s)?;
+//        len += self.password.encode(&mut s)?;
+//        Ok(len)
+//    }
+//}
+//
+//impl Decodable for DarkfidCliConfig {
+//    fn decode<D: std::io::Read>(mut d: D) -> Result<Self> {
+//        Ok(Self {
+//            connect_url: Decodable::decode(&mut d)?,
+//            subscriber_url: Decodable::decode(&mut d)?,
+//            rpc_url: Decodable::decode(&mut d)?,
+//            database_path: Decodable::decode(&mut d)?,
+//            log_path: Decodable::decode(&mut d)?,
+//            password: Decodable::decode(&mut d)?,
+//        })
+//    }
+//}
 
-impl Encodable for DrkCliConfig {
-    fn encode<S: std::io::Write>(&self, mut s: S) -> Result<usize> {
-        let mut len = 0;
-        len += self.rpc_url.encode(&mut s)?;
-        len += self.log_path.encode(&mut s)?;
-        Ok(len)
-    }
-}
-
-impl Decodable for DrkCliConfig {
-    fn decode<D: std::io::Read>(mut d: D) -> Result<Self> {
-        Ok(Self {
-            rpc_url: Decodable::decode(&mut d)?,
-            log_path: Decodable::decode(&mut d)?,
-        })
-    }
-}
+//impl Default for DarkfidCliConfig {
+//    // create default config file
+//    fn default() -> Self {
+//        //toml::toml! {
+//        //    connect-url = "127.0.0.1:3333"
+//        //};
+//        let connect_url = String::from("127.0.0.1:3333");
+//        let subscriber_url = String::from("127.0.0.1:4444");
+//        let rpc_url = String::from("127.0.0.1:8000");
+//
+//        let database_path = String::from("database_client.db");
+//        let database_path = join_config_path(&PathBuf::from(database_path))
+//            .expect("error during join database_path to config path");
+//        let database_path = String::from(
+//            database_path
+//                .to_str()
+//                .expect("error convert Path to String"),
+//        );
+//        let log_path = String::from("/tmp/darkfid_service_daemon.log");
+//
+//        let password = String::new();
+//        Self {
+//            connect_url,
+//            subscriber_url,
+//            rpc_url,
+//            database_path,
+//            log_path,
+//            password,
+//        }
+//    }
+//}
 
+//impl Encodable for DrkCliConfig {
+//    fn encode<S: std::io::Write>(&self, mut s: S) -> Result<usize> {
+//        let mut len = 0;
+//        len += self.rpc_url.encode(&mut s)?;
+//        len += self.log_path.encode(&mut s)?;
+//        Ok(len)
+//    }
+//}
+//
+//impl Decodable for DrkCliConfig {
+//    fn decode<D: std::io::Read>(mut d: D) -> Result<Self> {
+//        Ok(Self {
+//            rpc_url: Decodable::decode(&mut d)?,
+//            log_path: Decodable::decode(&mut d)?,
+//        })
+//    }
+//}

src/cli/client_cli/darkfid_cli.rs

@@ -1,15 +1,15 @@
-use super::cli_config::DarkfidCliConfig;
+//use super::cli_config::DarkfidCliConfig;
 use crate::Result;
 
-use clap::{App, AppSettings, Arg};
+use clap::{App, Arg};
 
 pub struct DarkfidCli {
-    pub change_config: bool,
+    //pub change_config: bool,
     pub verbose: bool,
 }
 
 impl DarkfidCli {
-    pub fn load(config: &mut DarkfidCliConfig) -> Result<Self> {
+    pub fn load() -> Result<Self> {
         let app = App::new("Darkfi Daemon CLI")
             .version("0.1.0")
             .author("Amir Taaki <amir@dyne.org>")
@@ -21,100 +21,100 @@ impl DarkfidCli {
                     .long("verbose")
                     .takes_value(false),
             )
-            .subcommand(
-                App::new("config")
-                    .about("Configuration settings")
-                    .aliases(&["get", "set"])
-                    .setting(AppSettings::SubcommandRequiredElseHelp)
-                    .subcommand(App::new("get").about("Get configuration settings"))
-                    .subcommand(
-                        App::new("set")
-                            .about("Set configuration settings")
-                            .args(&[
-                                Arg::new("connect_url")
-                                    .about("Set Connect Url")
-                                    .long("connect-url")
-                                    .takes_value(true),
-                                Arg::new("subscriber_url")
-                                    .about("Set Subscriber Url")
-                                    .long("subscriber-url")
-                                    .takes_value(true),
-                                Arg::new("rpc_url")
-                                    .about("Set RPC Url")
-                                    .long("rpc-url")
-                                    .takes_value(true),
-                                Arg::new("database_path")
-                                    .about("Set Database Path")
-                                    .long("database-path")
-                                    .takes_value(true),
-                                Arg::new("log_path")
-                                    .about("Set Log Path")
-                                    .long("log-path")
-                                    .takes_value(true),
-                                Arg::new("password")
-                                    .about("Set password")
-                                    .long("password")
-                                    .takes_value(true),
-                            ])
-                            .setting(AppSettings::ArgRequiredElseHelp),
-                    ),
-            )
+            //.subcommand(
+            //    App::new("config")
+            //        .about("Configuration settings")
+            //        .aliases(&["get", "set"])
+            //        .setting(AppSettings::SubcommandRequiredElseHelp)
+            //        .subcommand(App::new("get").about("Get configuration settings"))
+            //        .subcommand(
+            //            App::new("set")
+            //                .about("Set configuration settings")
+            //                .args(&[
+            //                    Arg::new("connect_url")
+            //                        .about("Set Connect Url")
+            //                        .long("connect-url")
+            //                        .takes_value(true),
+            //                    Arg::new("subscriber_url")
+            //                        .about("Set Subscriber Url")
+            //                        .long("subscriber-url")
+            //                        .takes_value(true),
+            //                    Arg::new("rpc_url")
+            //                        .about("Set RPC Url")
+            //                        .long("rpc-url")
+            //                        .takes_value(true),
+            //                    Arg::new("database_path")
+            //                        .about("Set Database Path")
+            //                        .long("database-path")
+            //                        .takes_value(true),
+            //                    Arg::new("log_path")
+            //                        .about("Set Log Path")
+            //                        .long("log-path")
+            //                        .takes_value(true),
+            //                    Arg::new("password")
+            //                        .about("Set password")
+            //                        .long("password")
+            //                        .takes_value(true),
+            //                ])
+            //                .setting(AppSettings::ArgRequiredElseHelp),
+            //        ),
+            //)
             .get_matches();
 
-        let mut change_config = false;
+        //let mut change_config = false;
 
         let verbose = app.is_present("verbose");
 
-        match app.subcommand_matches("config") {
-            Some(config_sub) => match config_sub.subcommand() {
-                Some(c) => match c {
-                    ("get", _) => {
-                        change_config = true;
-                        println!("Connect Url: {}", config.connect_url);
-                        println!("Subscriber Url: {}", config.subscriber_url);
-                        println!("RPC Url: {}", config.rpc_url);
-                        println!("Database path: {}", config.database_path);
-                        println!("Log Path: {}", config.log_path);
-                        if config.password.trim().is_empty() {
-                            println!("Password is empty. Please set a password.")
-                        };
-                    }
-                    ("set", c) => {
-                        change_config = true;
-                        if let Some(v) = c.value_of("connect_url") {
-                            config.connect_url = v.to_string();
-                            println!("Change Connect Url To {}", config.connect_url);
-                        }
-                        if let Some(v) = c.value_of("subscriber_url") {
-                            config.subscriber_url = v.to_string();
-                            println!("Change Subscriber Url To {}", config.subscriber_url);
-                        }
-                        if let Some(v) = c.value_of("rpc_url") {
-                            config.rpc_url = v.to_string();
-                            println!("Change RPC Url To {}", config.rpc_url);
-                        }
-                        if let Some(v) = c.value_of("database_path") {
-                            config.database_path = v.to_string();
-                            println!("Change Database Path To {}", config.database_path);
-                        }
-                        if let Some(v) = c.value_of("log_path") {
-                            config.log_path = v.to_string();
-                            println!("Change Log Path To {}", config.log_path);
-                        }
-                        if let Some(v) = c.value_of("password") {
-                            config.password = v.to_string();
-                            println!("Updated password.");
-                        }
-                    }
-                    _ => {}
-                },
-                None => {}
-            },
-            None => {}
-        }
+        //match app.subcommand_matches("config") {
+        //    Some(config_sub) => match config_sub.subcommand() {
+        //        Some(c) => match c {
+        //            ("get", _) => {
+        //                change_config = true;
+        //                println!("Connect Url: {}", config.connect_url);
+        //                println!("Subscriber Url: {}", config.subscriber_url);
+        //                println!("RPC Url: {}", config.rpc_url);
+        //                println!("Database path: {}", config.database_path);
+        //                println!("Log Path: {}", config.log_path);
+        //                if config.password.trim().is_empty() {
+        //                    println!("Password is empty. Please set a password.")
+        //                };
+        //            }
+        //            ("set", c) => {
+        //                change_config = true;
+        //                if let Some(v) = c.value_of("connect_url") {
+        //                    config.connect_url = v.to_string();
+        //                    println!("Change Connect Url To {}", config.connect_url);
+        //                }
+        //                if let Some(v) = c.value_of("subscriber_url") {
+        //                    config.subscriber_url = v.to_string();
+        //                    println!("Change Subscriber Url To {}", config.subscriber_url);
+        //                }
+        //                if let Some(v) = c.value_of("rpc_url") {
+        //                    config.rpc_url = v.to_string();
+        //                    println!("Change RPC Url To {}", config.rpc_url);
+        //                }
+        //                if let Some(v) = c.value_of("database_path") {
+        //                    config.database_path = v.to_string();
+        //                    println!("Change Database Path To {}", config.database_path);
+        //                }
+        //                if let Some(v) = c.value_of("log_path") {
+        //                    config.log_path = v.to_string();
+        //                    println!("Change Log Path To {}", config.log_path);
+        //                }
+        //                if let Some(v) = c.value_of("password") {
+        //                    config.password = v.to_string();
+        //                    println!("Updated password. New password: {}", config.password);
+        //                }
+        //            }
+        //            _ => {}
+        //        },
+        //        None => {}
+        //    },
+        //    None => {}
+        //}
 
         Ok(Self {
-            change_config,
+            //change_config,
             verbose,
         })
     }

src/cli/client_cli/drk_cli.rs

@@ -1,7 +1,7 @@
-use super::cli_config::DrkCliConfig;
+//use super::cli_config::DrkCliConfig;
 use crate::Result;
 
-use clap::{App, AppSettings, Arg};
+use clap::{App, Arg};
 
 pub struct Transfer {
     pub pub_key: String,
@@ -30,7 +30,7 @@ impl Transfer {
 }
 
 pub struct DrkCli {
-    pub change_config: bool,
+    //pub change_config: bool,
     pub verbose: bool,
     pub cashier: bool,
     pub wallet: bool,
@@ -42,7 +42,7 @@ pub struct DrkCli {
 }
 
 impl DrkCli {
-    pub fn load(config: &mut DrkCliConfig) -> Result<Self> {
+    pub fn load() -> Result<Self> {
         let app = App::new("Drk CLI")
             .version("0.1.0")
             .author("Amir Taaki <amir@dyne.org>")
@@ -115,31 +115,31 @@ impl DrkCli {
                             .required(true),
                     ),
             )
-            .subcommand(
-                App::new("config")
-                    .about("Configuration settings")
-                    .aliases(&["get", "set"])
-                    .setting(AppSettings::SubcommandRequiredElseHelp)
-                    .subcommand(App::new("get").about("Get configuration settings"))
-                    .subcommand(
-                        App::new("set")
-                            .about("Set configuration settings")
-                            .args(&[
-                                Arg::new("rpc_url")
-                                    .about("Set RPC Url")
-                                    .long("rpc-url")
-                                    .takes_value(true),
-                                Arg::new("log_path")
-                                    .about("Set Log Path")
-                                    .long("log-path")
-                                    .takes_value(true),
-                            ])
-                            .setting(AppSettings::ArgRequiredElseHelp),
-                    ),
-            )
+            //.subcommand(
+            //    App::new("config")
+            //        .about("Configuration settings")
+            //        .aliases(&["get", "set"])
+            //        .setting(AppSettings::SubcommandRequiredElseHelp)
+            //        .subcommand(App::new("get").about("Get configuration settings"))
+            //        .subcommand(
+            //            App::new("set")
+            //                .about("Set configuration settings")
+            //                .args(&[
+            //                    Arg::new("rpc_url")
+            //                        .about("Set RPC Url")
+            //                        .long("rpc-url")
+            //                        .takes_value(true),
+            //                    Arg::new("log_path")
+            //                        .about("Set Log Path")
+            //                        .long("log-path")
+            //                        .takes_value(true),
+            //                ])
+            //                .setting(AppSettings::ArgRequiredElseHelp),
+            //        ),
+            //)
             .get_matches();
 
-        let mut change_config = false;
+        //let mut change_config = false;
 
         let verbose = app.is_present("verbose");
         let cashier = app.is_present("cashier");
@@ -165,34 +165,34 @@ impl DrkCli {
             None => {}
         }
 
-        match app.subcommand_matches("config") {
-            Some(config_sub) => match config_sub.subcommand() {
-                Some(c) => match c {
-                    ("get", _) => {
-                        change_config = true;
-                        println!("RPC Url: {}", config.rpc_url);
-                        println!("Log Path: {}", config.log_path);
-                    }
-                    ("set", c) => {
-                        change_config = true;
-                        if let Some(v) = c.value_of("rpc_url") {
-                            config.rpc_url = v.to_string();
-                            println!("Change RPC Url To {}", config.rpc_url);
-                        }
-                        if let Some(v) = c.value_of("log_path") {
-                            config.log_path = v.to_string();
-                            println!("Change Log Path To {}", config.log_path);
-                        }
-                    }
-                    _ => {}
-                },
-                None => {}
-            },
-            None => {}
-        }
+        //match app.subcommand_matches("config") {
+        //    Some(config_sub) => match config_sub.subcommand() {
+        //        Some(c) => match c {
+        //            ("get", _) => {
+        //                change_config = true;
+        //                println!("RPC Url: {}", config.rpc_url);
+        //                println!("Log Path: {}", config.log_path);
+        //            }
+        //            ("set", c) => {
+        //                change_config = true;
+        //                if let Some(v) = c.value_of("rpc_url") {
+        //                    config.rpc_url = v.to_string();
+        //                    println!("Change RPC Url To {}", config.rpc_url);
+        //                }
+        //                if let Some(v) = c.value_of("log_path") {
+        //                    config.log_path = v.to_string();
+        //                    println!("Change Log Path To {}", config.log_path);
+        //                }
+        //            }
+        //            _ => {}
+        //        },
+        //        None => {}
+        //    },
+        //    None => {}
+        //}
 
         Ok(Self {
-            change_config,
+            //change_config,
             verbose,
             cashier,
             wallet,

src/cli/client_cli/mod.rs

@@ -1,3 +1,3 @@
 pub mod cli_config;
-pub mod drk_cli; 
 pub mod darkfid_cli;
+pub mod drk_cli;

src/cli/mod.rs

@@ -1,6 +1,6 @@
 pub mod client_cli;
 pub mod service_cli;
 
-pub use client_cli::{drk_cli::DrkCli, drk_cli::Transfer, darkfid_cli::DarkfidCli};
-pub use client_cli::cli_config::{DarkfidCliConfig, DrkCliConfig, ClientCliConfig};
+pub use client_cli::cli_config::{DarkfidCliConfig, DrkCliConfig};
+pub use client_cli::{darkfid_cli::DarkfidCli, drk_cli::DrkCli, drk_cli::Transfer};
 pub use service_cli::ServiceCli;

src/error.rs

@@ -36,6 +36,7 @@ pub enum Error {
     ChannelTimeout,
     ServiceStopped,
     Utf8Error,
+    StrUtf8Error(String),
     NoteDecryptionFailed,
     ServicesError(&'static str),
     ZMQError(String),
@@ -48,6 +49,8 @@ pub enum Error {
     SerdeJsonError(String),
     SurfHttpError(String),
     EmptyPassword,
+    TomlDeserializeError(String),
+    TomlSerializeError(String),
 }
 
 impl std::error::Error for Error {}
@@ -80,6 +83,7 @@ impl fmt::Display for Error {
             Error::ChannelTimeout => f.write_str("Channel timed out"),
             Error::ServiceStopped => f.write_str("Service stopped"),
             Error::Utf8Error => f.write_str("Malformed UTF8"),
+            Error::StrUtf8Error(ref err) => write!(f, "Malformed UTF8: {}", err),
             Error::NoteDecryptionFailed => f.write_str("Unable to decrypt mint note"),
             Error::ServicesError(ref err) => write!(f, "Services error: {}", err),
             Error::ZMQError(ref err) => write!(f, "ZMQError: {}", err),
@@ -92,6 +96,8 @@ impl fmt::Display for Error {
             Error::SerdeJsonError(ref err) => write!(f, "Json serialization error: {}", err),
             Error::SurfHttpError(ref err) => write!(f, "Surf Http error: {}", err),
             Error::EmptyPassword => f.write_str("Password is empty. Cannot create database"),
+            Error::TomlDeserializeError(ref err) => write!(f, "Toml parsing error: {}", err),
+            Error::TomlSerializeError(ref err) => write!(f, "Toml parsing error: {}", err),
         }
     }
 }
@@ -182,6 +188,12 @@ impl From<std::string::FromUtf8Error> for Error {
     }
 }
 
+impl From<std::str::Utf8Error> for Error {
+    fn from(err: std::str::Utf8Error) -> Error {
+        Error::StrUtf8Error(err.to_string())
+    }
+}
+
 impl From<state::VerifyFailed> for Error {
     fn from(_err: state::VerifyFailed) -> Error {
         Error::VerifyFailed
@@ -193,3 +205,15 @@ impl From<surf::Error> for Error {
         Error::SurfHttpError(err.to_string())
     }
 }
+
+impl From<toml::de::Error> for Error {
+    fn from(err: toml::de::Error) -> Error {
+        Error::TomlDeserializeError(err.to_string())
+    }
+}
+
+impl From<toml::ser::Error> for Error {
+    fn from(err: toml::ser::Error) -> Error {
+        Error::TomlSerializeError(err.to_string())
+    }
+}

src/rpc/jsonserver.rs

@@ -73,7 +73,7 @@ pub async fn listen(
 
 pub async fn start(
     executor: Arc<Executor<'_>>,
-    config: Arc<DarkfidCliConfig>,
+    config: Arc<&DarkfidCliConfig>,
     adapter: RpcAdapter,
 ) -> Result<()> {
     let rpc = RpcInterface::new(adapter)?;

src/wallet/walletdb.rs

@@ -2,7 +2,7 @@ use crate::crypto::{coin::Coin, merkle::IncrementalWitness, merkle_node::MerkleN
 use crate::serial;
 use crate::serial::{deserialize, serialize, Decodable, Encodable};
 use crate::util::join_config_path;
-use crate::{Result, Error};
+use crate::{Error, Result};
 
 use async_std::sync::{Arc, Mutex};
 use ff::Field;
@@ -56,15 +56,12 @@ impl WalletDB {
             let contents = include_str!("../../res/schema.sql");
             let conn = Connection::open(&self.path)?;
             debug!(target: "walletdb", "OPENED CONNECTION AT PATH {:?}", self.path);
-            conn.execute(
-                "PRAGMA key=(?1)",
-                params![self.password],
-            )?;
+            conn.execute("PRAGMA key=(?1)", params![self.password])?;
             conn.execute_batch(&contents)?
-        }
-        else {
+        } else {
             println!("Password is empty. You must set a password to use the wallet.");
-            return Err(Error::EmptyPassword)
+            println!("Current password: {}", self.password);
+            return Err(Error::EmptyPassword);
         }
         Ok(())
     }
@@ -96,10 +93,7 @@ impl WalletDB {
         // open connection
         let conn = Connection::open(&self.path)?;
         // unlock database
-        conn.execute(
-            "PRAGMA key=(?1)",
-            params![self.password],
-        )?;
+        conn.execute("PRAGMA key=(?1)", params![self.password])?;
         // return key_id from key_private
         let mut get_id =
             conn.prepare("SELECT key_id FROM keys WHERE key_private = :key_private")?;
@@ -145,10 +139,7 @@ impl WalletDB {
 
     pub fn put_keypair(&self, key_public: Vec<u8>, key_private: Vec<u8>) -> Result<()> {
         let conn = Connection::open(&self.path)?;
-        conn.execute(
-            "PRAGMA key=(?1)",
-            params![self.password],
-        )?;
+        conn.execute("PRAGMA key=(?1)", params![self.password])?;
         conn.execute(
             "INSERT INTO keys(key_public, key_private) VALUES (?1, ?2)",
             params![key_public, key_private],
@@ -159,10 +150,7 @@ impl WalletDB {
     pub fn put_cashier_pub(&self, key_public: Vec<u8>) -> Result<()> {
         debug!(target: "save_cash_key", "Save cashier keys...");
         let conn = Connection::open(&self.path)?;
-        conn.execute(
-            "PRAGMA key=(?1)",
-            params![self.password],
-        )?;
+        conn.execute("PRAGMA key=(?1)", params![self.password])?;
         conn.execute(
             "INSERT INTO cashier(key_public) VALUES (?1)",
             params![key_public],
@@ -173,10 +161,7 @@ impl WalletDB {
     pub fn get_public(&self) -> Result<Vec<u8>> {
         debug!(target: "get", "Returning keys...");
         let conn = Connection::open(&self.path)?;
-        conn.execute(
-            "PRAGMA key=(?1)",
-            params![self.password],
-        )?;
+        conn.execute("PRAGMA key=(?1)", params![self.password])?;
         let mut stmt = conn.prepare("SELECT key_public FROM keys")?;
         let key_iter = stmt.query_map::<u8, _, _>([], |row| row.get(0))?;
         let mut pub_keys = Vec::new();
@@ -189,10 +174,7 @@ impl WalletDB {
     pub fn get_cashier_public(&self) -> Result<Vec<u8>> {
         debug!(target: "get_cashier_public", "Returning keys...");
         let conn = Connection::open(&self.path)?;
-        conn.execute(
-            "PRAGMA key=(?1)",
-            params![self.password],
-        )?;
+        conn.execute("PRAGMA key=(?1)", params![self.password])?;
         let mut stmt = conn.prepare("SELECT key_public FROM cashier")?;
         let key_iter = stmt.query_map::<u8, _, _>([], |row| row.get(0))?;
         let mut pub_keys = Vec::new();
@@ -205,10 +187,7 @@ impl WalletDB {
     pub fn get_private(&self) -> Result<Vec<u8>> {
         debug!(target: "get", "Returning keys...");
         let conn = Connection::open(&self.path)?;
-        conn.execute(
-            "PRAGMA key=(?1)",
-            params![self.password],
-        )?;
+        conn.execute("PRAGMA key=(?1)", params![self.password])?;
         let mut stmt = conn.prepare("SELECT key_private FROM keys")?;
         let key_iter = stmt.query_map::<u8, _, _>([], |row| row.get(0))?;
         let mut keys = Vec::new();
@@ -220,10 +199,7 @@ impl WalletDB {
 
     pub fn test_wallet(&self) -> Result<()> {
         let conn = Connection::open(&self.path)?;
-        conn.execute(
-            "PRAGMA key=(?1)",
-            params![self.password],
-        )?;
+        conn.execute("PRAGMA key=(?1)", params![self.password])?;
         let mut stmt = conn.prepare("SELECT * FROM keys")?;
         let _rows = stmt.query([])?;
         Ok(())