feat: add support for MultiAddr in RPC config

applications/tari_base_node/src/main.rs

@@ -114,7 +114,11 @@ use tari_app_utilities::{
     utilities::setup_runtime,
 };
 use tari_common::{configuration::bootstrap::ApplicationType, exit_codes::ExitCodes, ConfigBootstrap, GlobalConfig};
-use tari_comms::{peer_manager::PeerFeatures, tor::HiddenServiceControllerError};
+use tari_comms::{
+    peer_manager::PeerFeatures,
+    tor::HiddenServiceControllerError,
+    utils::multiaddr::multiaddr_to_socketaddr,
+};
 use tari_core::chain_storage::ChainStorageError;
 use tari_shutdown::{Shutdown, ShutdownSignal};
 use tokio::{
@@ -228,7 +232,9 @@ async fn run_node(node_config: Arc<GlobalConfig>, bootstrap: ConfigBootstrap) ->
     if node_config.grpc_enabled {
         // Go, GRPC, go go
         let grpc = crate::grpc::base_node_grpc_server::BaseNodeGrpcServer::from_base_node_context(&ctx);
-        task::spawn(run_grpc(grpc, node_config.grpc_base_node_address, shutdown.to_signal()));
+        let socket_addr = multiaddr_to_socketaddr(&node_config.grpc_base_node_address)
+            .map_err(|e| ExitCodes::ConfigError(e.to_string()))?;
+        task::spawn(run_grpc(grpc, socket_addr, shutdown.to_signal()));
     }
 
     // Run, node, run!

applications/tari_console_wallet/src/wallet_modes.rs

@@ -30,9 +30,9 @@ use crate::{
 };
 use log::*;
 use rand::{rngs::OsRng, seq::SliceRandom};
-use std::{fs, io::Stdout, net::SocketAddr, path::PathBuf};
+use std::{fs, io::Stdout, path::PathBuf};
 use tari_common::{exit_codes::ExitCodes, ConfigBootstrap, GlobalConfig};
-use tari_comms::peer_manager::Peer;
+use tari_comms::{multiaddr::Multiaddr, peer_manager::Peer, utils::multiaddr::multiaddr_to_socketaddr};
 use tari_wallet::WalletSqlite;
 use tokio::runtime::Handle;
 use tonic::transport::Server;
@@ -213,7 +213,7 @@ pub fn tui_mode(config: WalletModeConfig, mut wallet: WalletSqlite) -> Result<()
         ..
     } = config;
     let grpc = WalletGrpcServer::new(wallet.clone());
-    handle.spawn(run_grpc(grpc, global_config.grpc_console_wallet_address));
+    handle.spawn(run_grpc(grpc, global_config.grpc_console_wallet_address.clone()));
 
     let notifier = Notifier::new(notify_script, handle.clone(), wallet.clone());
 
@@ -294,12 +294,12 @@ pub fn grpc_mode(config: WalletModeConfig, wallet: WalletSqlite) -> Result<(), E
     Ok(())
 }
 
-async fn run_grpc(grpc: WalletGrpcServer, grpc_console_wallet_address: SocketAddr) -> Result<(), String> {
+async fn run_grpc(grpc: WalletGrpcServer, grpc_console_wallet_address: Multiaddr) -> Result<(), String> {
     info!(target: LOG_TARGET, "Starting GRPC on {}", grpc_console_wallet_address);
-
+    let socket = multiaddr_to_socketaddr(&grpc_console_wallet_address).map_err(|e| e.to_string())?;
     Server::builder()
         .add_service(tari_app_grpc::tari_rpc::wallet_server::WalletServer::new(grpc))
-        .serve(grpc_console_wallet_address)
+        .serve(socket)
         .await
         .map_err(|e| format!("GRPC server returned error:{}", e))?;
     info!(target: LOG_TARGET, "Stopping GRPC");

applications/tari_merge_mining_proxy/Cargo.toml

@@ -14,6 +14,7 @@ envlog = ["env_logger"]
 [dependencies]
 tari_app_grpc = { path = "../tari_app_grpc" }
 tari_common = { path = "../../common" }
+tari_comms = { path = "../../comms" }
 tari_core = { path = "../../base_layer/core", default-features = false, features = ["transactions"] }
 tari_app_utilities = { path = "../tari_app_utilities" }
 tari_crypto = { git = "https://github.com/tari-project/tari-crypto.git", branch = "main" }

applications/tari_merge_mining_proxy/src/main.rs

@@ -40,7 +40,7 @@ use crate::{block_template_data::BlockTemplateRepository, error::MmProxyError};
 use futures::future;
 use hyper::{service::make_service_fn, Server};
 use proxy::{MergeMiningProxyConfig, MergeMiningProxyService};
-use std::convert::Infallible;
+use std::convert::{Infallible, TryFrom};
 use tari_app_grpc::tari_rpc as grpc;
 use tari_app_utilities::initialization::init_configuration;
 use tari_common::configuration::bootstrap::ApplicationType;
@@ -50,7 +50,7 @@ use tokio::time::Duration;
 async fn main() -> Result<(), anyhow::Error> {
     let (_, config, _) = init_configuration(ApplicationType::MergeMiningProxy)?;
 
-    let config = MergeMiningProxyConfig::from(config);
+    let config = MergeMiningProxyConfig::try_from(config)?;
     let addr = config.proxy_host_address;
     let client = reqwest::Client::builder()
         .connect_timeout(Duration::from_secs(5))

applications/tari_merge_mining_proxy/src/proxy.rs

@@ -34,6 +34,7 @@ use reqwest::{ResponseBuilderExt, Url};
 use serde_json as json;
 use std::{
     cmp,
+    convert::TryFrom,
     future::Future,
     net::SocketAddr,
     pin::Pin,
@@ -46,6 +47,7 @@ use std::{
 };
 use tari_app_grpc::tari_rpc as grpc;
 use tari_common::{configuration::Network, GlobalConfig};
+use tari_comms::utils::multiaddr::multiaddr_to_socketaddr;
 use tari_core::proof_of_work::{monero_rx, monero_rx::FixedByteArray};
 use tari_utilities::hex::Hex;
 use tracing::{debug, error, info, instrument, trace, warn};
@@ -70,20 +72,24 @@ pub struct MergeMiningProxyConfig {
     pub wait_for_initial_sync_at_startup: bool,
 }
 
-impl From<GlobalConfig> for MergeMiningProxyConfig {
-    fn from(config: GlobalConfig) -> Self {
-        Self {
+impl TryFrom<GlobalConfig> for MergeMiningProxyConfig {
+    type Error = std::io::Error;
+
+    fn try_from(config: GlobalConfig) -> Result<Self, Self::Error> {
+        let grpc_base_node_address = multiaddr_to_socketaddr(&config.grpc_base_node_address)?;
+        let grpc_console_wallet_address = multiaddr_to_socketaddr(&config.grpc_console_wallet_address)?;
+        Ok(Self {
             network: config.network,
             monerod_url: config.monerod_url,
             monerod_username: config.monerod_username,
             monerod_password: config.monerod_password,
             monerod_use_auth: config.monerod_use_auth,
-            grpc_base_node_address: config.grpc_base_node_address,
-            grpc_console_wallet_address: config.grpc_console_wallet_address,
+            grpc_base_node_address,
+            grpc_console_wallet_address,
             proxy_host_address: config.proxy_host_address,
             proxy_submit_to_origin: config.proxy_submit_to_origin,
             wait_for_initial_sync_at_startup: config.wait_for_initial_sync_at_startup,
-        }
+        })
     }
 }
 

applications/tari_mining_node/Cargo.toml

@@ -10,6 +10,7 @@ edition = "2018"
 [dependencies]
 tari_core = { path = "../../base_layer/core",  default-features = false }
 tari_common = {  path = "../../common" }
+tari_comms = {  path = "../../comms" }
 tari_app_utilities = { path = "../tari_app_utilities"}
 tari_app_grpc = {  path = "../tari_app_grpc" }
 tari_crypto = { git = "https://github.com/tari-project/tari-crypto.git", branch = "main" }

applications/tari_mining_node/src/config.rs

@@ -40,11 +40,10 @@ use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use tari_app_grpc::tari_rpc::{pow_algo::PowAlgos, NewBlockTemplateRequest, PowAlgo};
 use tari_common::{GlobalConfig, NetworkConfigPath};
+use tari_comms::utils::multiaddr::multiaddr_to_socketaddr;
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct MinerConfig {
-    pub base_node_grpc_address: Option<String>,
-    pub wallet_grpc_address: Option<String>,
     pub num_mining_threads: usize,
     pub mine_on_tip_only: bool,
     pub proof_of_work_algo: ProofOfWork,
@@ -68,8 +67,6 @@ impl NetworkConfigPath for MinerConfig {
 impl Default for MinerConfig {
     fn default() -> Self {
         Self {
-            base_node_grpc_address: None,
-            wallet_grpc_address: None,
             num_mining_threads: num_cpus::get(),
             mine_on_tip_only: true,
             proof_of_work_algo: ProofOfWork::Sha3,
@@ -82,16 +79,14 @@ impl Default for MinerConfig {
 }
 
 impl MinerConfig {
-    pub fn base_node_addr(&self, global: &GlobalConfig) -> String {
-        self.base_node_grpc_address
-            .clone()
-            .unwrap_or_else(|| format!("http://{}", global.grpc_base_node_address))
+    pub fn base_node_addr(&self, global: &GlobalConfig) -> Result<String, std::io::Error> {
+        let socket = multiaddr_to_socketaddr(&global.grpc_base_node_address)?;
+        Ok(format!("http://{}", socket))
     }
 
-    pub fn wallet_addr(&self, global: &GlobalConfig) -> String {
-        self.wallet_grpc_address
-            .clone()
-            .unwrap_or_else(|| format!("http://{}", global.grpc_console_wallet_address))
+    pub fn wallet_addr(&self, global: &GlobalConfig) -> Result<String, std::io::Error> {
+        let socket = multiaddr_to_socketaddr(&global.grpc_console_wallet_address)?;
+        Ok(format!("http://{}", socket))
     }
 
     pub fn pow_algo_request(&self) -> NewBlockTemplateRequest {

applications/tari_mining_node/src/errors.rs

@@ -24,6 +24,8 @@ use thiserror::Error;
 
 #[derive(Debug, Error)]
 pub enum MinerError {
+    #[error("I/O error")]
+    IOError(#[from] std::io::Error),
     #[error("GRPC error: {0}")]
     GrpcStatus(#[from] tonic::Status),
     #[error("Connection error: {0}")]

applications/tari_mining_node/src/main.rs

@@ -223,12 +223,12 @@ async fn connect(
     config: &MinerConfig,
     global: &GlobalConfig,
 ) -> Result<(BaseNodeClient<Channel>, WalletClient<Channel>), MinerError> {
-    let base_node_addr = config.base_node_addr(global);
+    let base_node_addr = config.base_node_addr(global)?;
     info!(target: LOG_TARGET, "Connecting to base node at {}", base_node_addr);
-    let node_conn = BaseNodeClient::connect(base_node_addr.clone()).await?;
-    let wallet_addr = config.wallet_addr(global);
+    let node_conn = BaseNodeClient::connect(base_node_addr).await?;
+    let wallet_addr = config.wallet_addr(global)?;
     info!(target: LOG_TARGET, "Connecting to wallet at {}", wallet_addr);
-    let wallet_conn = WalletClient::connect(wallet_addr.clone()).await?;
+    let wallet_conn = WalletClient::connect(wallet_addr).await?;
 
     Ok((node_conn, wallet_conn))
 }

applications/tari_stratum_transcoder/Cargo.toml

@@ -12,6 +12,7 @@ default = []
 envlog = ["env_logger"]
 
 [dependencies]
+tari_comms = { path = "../../comms" }
 tari_app_grpc = { path = "../tari_app_grpc" }
 tari_common = { path = "../../common" }
 tari_core = { path = "../../base_layer/core", default-features = false, features = ["transactions"] }

applications/tari_stratum_transcoder/src/main.rs

@@ -35,7 +35,7 @@ use crate::error::StratumTranscoderProxyError;
 use futures::future;
 use hyper::{service::make_service_fn, Server};
 use proxy::{StratumTranscoderProxyConfig, StratumTranscoderProxyService};
-use std::convert::Infallible;
+use std::convert::{Infallible, TryFrom};
 use structopt::StructOpt;
 use tari_app_grpc::tari_rpc as grpc;
 use tari_common::{configuration::bootstrap::ApplicationType, ConfigBootstrap, GlobalConfig};
@@ -45,7 +45,7 @@ use tokio::time::Duration;
 async fn main() -> Result<(), StratumTranscoderProxyError> {
     let config = initialize()?;
 
-    let config = StratumTranscoderProxyConfig::from(config);
+    let config = StratumTranscoderProxyConfig::try_from(config)?;
     let addr = config.transcoder_host_address;
     let client = reqwest::Client::builder()
         .connect_timeout(Duration::from_secs(5))

applications/tari_stratum_transcoder/src/proxy.rs

@@ -44,6 +44,7 @@ use std::{
 };
 use tari_app_grpc::{tari_rpc as grpc, tari_rpc::GetCoinbaseRequest};
 use tari_common::{configuration::Network, GlobalConfig};
+use tari_comms::utils::multiaddr::multiaddr_to_socketaddr;
 use tari_core::blocks::{Block, NewBlockTemplate};
 use tari_utilities::{hex::Hex, message_format::MessageFormat};
 use tracing::{debug, error};
@@ -58,14 +59,18 @@ pub struct StratumTranscoderProxyConfig {
     pub transcoder_host_address: SocketAddr,
 }
 
-impl From<GlobalConfig> for StratumTranscoderProxyConfig {
-    fn from(config: GlobalConfig) -> Self {
-        Self {
+impl TryFrom<GlobalConfig> for StratumTranscoderProxyConfig {
+    type Error = std::io::Error;
+
+    fn try_from(config: GlobalConfig) -> Result<Self, Self::Error> {
+        let grpc_base_node_address = multiaddr_to_socketaddr(&config.grpc_base_node_address)?;
+        let grpc_console_wallet_address = multiaddr_to_socketaddr(&config.grpc_console_wallet_address)?;
+        Ok(Self {
             network: config.network,
-            grpc_base_node_address: config.grpc_base_node_address,
-            grpc_console_wallet_address: config.grpc_console_wallet_address,
+            grpc_base_node_address,
+            grpc_console_wallet_address,
             transcoder_host_address: config.transcoder_host_address,
-        }
+        })
     }
 }