Move out tendermint::config to tendermint-config crate

Cargo.toml

@@ -2,6 +2,7 @@
 
 members = [
     "abci",
+    "config",
     "light-client",
     "light-client-js",
     "p2p",

abci/src/lib.rs

@@ -9,7 +9,7 @@
 //! have them interact. In practice, the client interaction will be performed
 //! by a full Tendermint node.
 //!
-//! ```rust
+//! ```ignore
 //! use tendermint_abci::{KeyValueStoreApp, ServerBuilder, ClientBuilder};
 //! use tendermint_proto::abci::{RequestEcho, RequestDeliverTx, RequestQuery};
 //!

config/Cargo.toml

@@ -0,0 +1,49 @@
+[package]
+name       = "tendermint-config"
+version    = "0.21.0" # Also update `html_root_url` in lib.rs and
+                      # depending crates (rpc, light-node, ..) when bumping this
+license    = "Apache-2.0"
+homepage   = "https://www.tendermint.com/"
+repository = "https://github.com/informalsystems/tendermint-rs/tree/master/tendermint"
+readme     = "../README.md"
+categories = ["cryptography", "cryptography::cryptocurrencies", "database"]
+keywords   = ["blockchain", "bft", "consensus", "cosmos", "tendermint"]
+edition    = "2018"
+
+description = """
+    tendermint-config provides functions for loading and validating Tendermint
+    configuration files. It is moved out of the tendermint crate for no_std support
+    in the tendermint crate.
+    """
+
+authors = [
+    "Informal Systems <[email protected]>",
+    "Ismail Khoffi <[email protected]>",
+    "ValarDragon <[email protected]>",
+    "Tony Arcieri <[email protected]>",
+]
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+tendermint = { version = "0.21.0", default-features = false, path = "../tendermint" }
+flex-error = { version = "0.4.1", default-features = false }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+toml = { version = "0.5" }
+url = { version = "2.2" }
+
+[dev-dependencies]
+pretty_assertions = "0.7.2"
+
+[features]
+default = ["std", "eyre_tracer"]
+eyre_tracer = ["flex-error/eyre_tracer"]
+std = [
+    "flex-error/std"
+]

tendermint/src/config.rs → config/src/config.rs

@@ -6,19 +6,18 @@
 //! - `node_key.rs`: `config::node_key::NodeKey`
 //! - `priv_validator_key.rs`: `config::priv_validator_key::PrivValidatorKey`
 
-mod node_key;
-mod priv_validator_key;
+use crate::net;
+use crate::node_key::NodeKey;
+use crate::Error;
 
-pub use self::{node_key::NodeKey, priv_validator_key::PrivValidatorKey};
-
-use crate::{error::Error, genesis::Genesis, net, node, Moniker, Timeout};
 use serde::{de, de::Error as _, ser, Deserialize, Serialize};
 use std::{
     collections::BTreeMap,
     fmt, fs,
     path::{Path, PathBuf},
     str::FromStr,
 };
+use tendermint::{genesis::Genesis, node, Moniker, Timeout};
 
 /// Tendermint `config.toml` file
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]

config/src/error.rs

@@ -0,0 +1,37 @@
+use flex_error::{define_error, DisplayOnly};
+use std::io::Error as IoError;
+use tendermint::Error as TendermintError;
+
+define_error! {
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    Error {
+        Io
+            [ DisplayOnly<IoError> ]
+            |_| { format_args!("I/O error") },
+
+        FileIo
+            { path: String }
+            [ DisplayOnly<IoError> ]
+            |e| { format_args!("failed to open file: {}", e.path) },
+
+        Parse
+            { data: String }
+            | e | { format_args!("error parsing data: {}", e.data) },
+
+        SerdeJson
+            [ DisplayOnly<serde_json::Error> ]
+            |_| { format_args!("serde json error") },
+
+        Toml
+            [ DisplayOnly<toml::de::Error> ]
+            |_| { format_args!("toml de error") },
+
+        ParseUrl
+            [ DisplayOnly<url::ParseError> ]
+            |_| { format_args!("error parsing url error") },
+
+        Tendermint
+            [ TendermintError ]
+            |_| { format_args!("tendermint error") },
+    }
+}

config/src/lib.rs

@@ -0,0 +1,27 @@
+//! Tendermint Configuration Utilities
+//!
+//! This crate defines the [`TendermintConfig`] type, which is used by
+//! crates such as `tendermint-rpc` to perform operations based on
+//! a common configuration type.
+
+#![cfg_attr(docsrs, feature(doc_cfg))]
+#![deny(
+    warnings,
+    trivial_casts,
+    trivial_numeric_casts,
+    unused_import_braces,
+    unused_qualifications
+)]
+#![forbid(unsafe_code)]
+
+pub mod net;
+
+mod config;
+mod error;
+mod node_key;
+mod priv_validator_key;
+
+pub use config::*;
+pub use error::*;
+pub use node_key::NodeKey;
+pub use priv_validator_key::PrivValidatorKey;

tendermint/src/net.rs → config/src/net.rs

@@ -1,13 +1,13 @@
 //! Remote addresses (`tcp://` or `unix://`)
 
-use crate::{error::Error, node};
+use crate::error::Error;
 
 use serde::{de::Error as _, Deserialize, Deserializer, Serialize, Serializer};
 use std::{
     fmt::{self, Display},
-    path::PathBuf,
     str::{self, FromStr},
 };
+use tendermint::node::{self, info::ListenAddress};
 use url::Url;
 
 /// URI prefix for TCP connections
@@ -40,10 +40,23 @@ pub enum Address {
     /// UNIX domain sockets
     Unix {
         /// Path to a UNIX domain socket path
-        path: PathBuf,
+        path: String,
     },
 }
 
+impl Address {
+    /// Convert `ListenAddress` to a `net::Address`
+    pub fn from_listen_address(address: &ListenAddress) -> Option<Self> {
+        let raw_address = address.as_str();
+        // TODO(tarcieri): validate these and handle them better at parse time
+        if raw_address.starts_with("tcp://") {
+            raw_address.parse().ok()
+        } else {
+            format!("tcp://{}", raw_address).parse().ok()
+        }
+    }
+}
+
 impl<'de> Deserialize<'de> for Address {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
         Self::from_str(&String::deserialize(deserializer)?)
@@ -64,7 +77,7 @@ impl Display for Address {
                 host,
                 port,
             } => write!(f, "{}{}@{}:{}", TCP_PREFIX, peer_id, host, port),
-            Address::Unix { path } => write!(f, "{}{}", UNIX_PREFIX, path.display()),
+            Address::Unix { path } => write!(f, "{}{}", UNIX_PREFIX, path),
         }
     }
 }
@@ -83,7 +96,8 @@ impl FromStr for Address {
         match url.scheme() {
             "tcp" => Ok(Self::Tcp {
                 peer_id: if !url.username().is_empty() {
-                    Some(url.username().parse()?)
+                    let username = url.username().parse().map_err(Error::tendermint)?;
+                    Some(username)
                 } else {
                     None
                 },
@@ -98,7 +112,7 @@ impl FromStr for Address {
                 })?,
             }),
             "unix" => Ok(Self::Unix {
-                path: PathBuf::from(url.path()),
+                path: url.path().to_string(),
             }),
             _ => Err(Error::parse(format!("invalid address scheme: {:?}", addr))),
         }
@@ -114,7 +128,7 @@ impl Serialize for Address {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::node;
+    use tendermint::node;
 
     const EXAMPLE_TCP_ADDR: &str =
         "tcp://[email protected]:26656";
@@ -175,7 +189,7 @@ mod tests {
         let addr = EXAMPLE_UNIX_ADDR.parse::<Address>().unwrap();
         match addr {
             Address::Unix { path } => {
-                assert_eq!(path.to_str().unwrap(), "/tmp/node.sock");
+                assert_eq!(path, "/tmp/node.sock");
             }
             other => panic!("unexpected address type: {:?}", other),
         }

tendermint/src/config/node_key.rs → config/src/node_key.rs

@@ -1,8 +1,10 @@
 //! Node keys
 
-use crate::{error::Error, node, private_key::PrivateKey, public_key::PublicKey};
 use serde::{Deserialize, Serialize};
 use std::{fs, path::Path};
+use tendermint::{node, private_key::PrivateKey, public_key::PublicKey};
+
+use crate::error::Error;
 
 /// P2P node private keys
 #[derive(Serialize, Deserialize)]
@@ -33,6 +35,7 @@ impl NodeKey {
     pub fn public_key(&self) -> PublicKey {
         match &self.priv_key {
             PrivateKey::Ed25519(keypair) => keypair.public.into(),
+            _ => todo!(),
         }
     }
 

tendermint/src/config/priv_validator_key.rs → config/src/priv_validator_key.rs

@@ -1,9 +1,11 @@
 //! Validator private keys
 
-use crate::public_key::TendermintKey;
-use crate::{account, error::Error, private_key::PrivateKey, public_key::PublicKey};
 use serde::{Deserialize, Serialize};
 use std::{fs, path::Path};
+use tendermint::public_key::TendermintKey;
+use tendermint::{account, private_key::PrivateKey, public_key::PublicKey};
+
+use crate::error::Error;
 
 /// Validator private key
 #[derive(Serialize, Deserialize)] // JSON custom serialization for priv_validator_key.json
@@ -25,7 +27,8 @@ impl PrivValidatorKey {
             serde_json::from_str::<Self>(json_string.as_ref()).map_err(Error::serde_json)?;
 
         // Validate that the parsed key type is usable as a consensus key
-        TendermintKey::new_consensus_key(result.priv_key.public_key())?;
+        TendermintKey::new_consensus_key(result.priv_key.public_key())
+            .map_err(Error::tendermint)?;
 
         Ok(result)
     }

tendermint/tests/config.rs → config/tests/config.rs

@@ -6,7 +6,8 @@ mod files {
     #[cfg(test)]
     use pretty_assertions::assert_eq;
     use std::{fs, path::PathBuf, time::Duration};
-    use tendermint::{config::*, net, node};
+    use tendermint::node;
+    use tendermint_config::*;
 
     /// Read a fixture file from the `support/config` directory
     fn read_fixture(name: &str) -> String {