Merge pull request #326 from KnowWhoami/maker-cli

Maker Cli testing

Author: mojoX911

src/bin/directory-cli.rs

@@ -15,6 +15,9 @@ use coinswap::{
 #[derive(Parser, Debug)]
 #[clap(author, version, about, long_about = None)]
 struct App {
+    /// Sets the rpc-port of DNS
+    #[clap(long, short = 'p', default_value = "127.0.0.1:4321")]
+    rpc_port: String,
     /// The command to execute
     #[clap(subcommand)]
     command: Commands,
@@ -26,8 +29,7 @@ enum Commands {
     ListAddresses,
 }
 
-fn send_rpc_req(req: &RpcMsgReq) -> Result<(), DirectoryServerError> {
-    let mut stream = TcpStream::connect("127.0.0.1:4321")?;
+fn send_rpc_req(mut stream: TcpStream, req: RpcMsgReq) -> Result<(), DirectoryServerError> {
     stream.set_read_timeout(Some(Duration::from_secs(20)))?;
     stream.set_write_timeout(Some(Duration::from_secs(20)))?;
 
@@ -44,9 +46,11 @@ fn main() -> Result<(), DirectoryServerError> {
     setup_directory_logger(log::LevelFilter::Info);
     let cli = App::parse();
 
+    let stream = TcpStream::connect(cli.rpc_port)?;
+
     match cli.command {
         Commands::ListAddresses => {
-            send_rpc_req(&RpcMsgReq::ListAddresses)?;
+            send_rpc_req(stream, RpcMsgReq::ListAddresses)?;
         }
     }
     Ok(())

src/bin/directoryd.rs

@@ -11,9 +11,9 @@ use std::{path::PathBuf, str::FromStr, sync::Arc};
 author = option_env ! ("CARGO_PKG_AUTHORS").unwrap_or(""))]
 struct Cli {
     /// Optional network type.
-    #[clap(long, short = 'n', default_value = "clearnet", possible_values = &["tor", "clearnet"])]
+    #[clap(long, short = 'n', default_value = "tor", possible_values = &["tor", "clearnet"])]
     network: String,
-    /// Optional DNS data directory. Default value : "~/.coinswap/directory"
+    /// Optional DNS data directory. Default value : "~/.coinswap/dns"
     #[clap(long, short = 'd')]
     data_directory: Option<PathBuf>,
 }

src/bin/maker-cli.rs

@@ -10,6 +10,9 @@ use coinswap::{
 #[derive(Parser, Debug)]
 #[clap(author, version, about, long_about = None)]
 struct App {
+    /// Sets the rpc-port of Makerd
+    #[clap(long, short = 'p', default_value = "127.0.0.1:6103")]
+    rpc_port: String,
     /// The command to execute
     #[clap(subcommand)]
     command: Commands,
@@ -37,77 +40,86 @@ enum Commands {
     FidelityBalance,
     /// Gets a new address
     NewAddress,
-    // Send to an external wallet address.
+    /// Send to an external address and returns the transaction hex.
     SendToAddress {
         address: String,
         amount: u64,
         fee: u64,
     },
     /// Returns the tor address
     GetTorAddress,
-    /// Returns the data dir
+    /// Returns the data directory path
     GetDataDir,
+    /// Stops the maker server
+    Stop,
 }
 
 fn main() -> Result<(), MakerError> {
     setup_maker_logger(log::LevelFilter::Info);
     let cli = App::parse();
 
+    let stream = TcpStream::connect(cli.rpc_port)?;
+
     match cli.command {
         Commands::Ping => {
-            send_rpc_req(&RpcMsgReq::Ping)?;
+            send_rpc_req(stream, RpcMsgReq::Ping)?;
         }
         Commands::ContractUtxo => {
-            send_rpc_req(&RpcMsgReq::ContractUtxo)?;
+            send_rpc_req(stream, RpcMsgReq::ContractUtxo)?;
         }
         Commands::ContractBalance => {
-            send_rpc_req(&RpcMsgReq::ContractBalance)?;
+            send_rpc_req(stream, RpcMsgReq::ContractBalance)?;
         }
         Commands::FidelityBalance => {
-            send_rpc_req(&RpcMsgReq::FidelityBalance)?;
+            send_rpc_req(stream, RpcMsgReq::FidelityBalance)?;
         }
         Commands::FidelityUtxo => {
-            send_rpc_req(&RpcMsgReq::FidelityUtxo)?;
+            send_rpc_req(stream, RpcMsgReq::FidelityUtxo)?;
         }
         Commands::SeedBalance => {
-            send_rpc_req(&RpcMsgReq::SeedBalance)?;
+            send_rpc_req(stream, RpcMsgReq::SeedBalance)?;
         }
         Commands::SeedUtxo => {
-            send_rpc_req(&RpcMsgReq::SeedUtxo)?;
+            send_rpc_req(stream, RpcMsgReq::SeedUtxo)?;
         }
         Commands::SwapBalance => {
-            send_rpc_req(&RpcMsgReq::SwapBalance)?;
+            send_rpc_req(stream, RpcMsgReq::SwapBalance)?;
         }
         Commands::SwapUtxo => {
-            send_rpc_req(&RpcMsgReq::SwapUtxo)?;
+            send_rpc_req(stream, RpcMsgReq::SwapUtxo)?;
         }
         Commands::NewAddress => {
-            send_rpc_req(&RpcMsgReq::NewAddress)?;
+            send_rpc_req(stream, RpcMsgReq::NewAddress)?;
         }
         Commands::SendToAddress {
             address,
             amount,
             fee,
         } => {
-            send_rpc_req(&RpcMsgReq::SendToAddress {
-                address,
-                amount,
-                fee,
-            })?;
+            send_rpc_req(
+                stream,
+                RpcMsgReq::SendToAddress {
+                    address,
+                    amount,
+                    fee,
+                },
+            )?;
         }
         Commands::GetTorAddress => {
-            send_rpc_req(&RpcMsgReq::GetTorAddress)?;
+            send_rpc_req(stream, RpcMsgReq::GetTorAddress)?;
         }
         Commands::GetDataDir => {
-            send_rpc_req(&RpcMsgReq::GetDataDir)?;
+            send_rpc_req(stream, RpcMsgReq::GetDataDir)?;
+        }
+        Commands::Stop => {
+            send_rpc_req(stream, RpcMsgReq::Stop)?;
         }
     }
 
     Ok(())
 }
 
-fn send_rpc_req(req: &RpcMsgReq) -> Result<(), MakerError> {
-    let mut stream = TcpStream::connect("127.0.0.1:6103")?;
+fn send_rpc_req(mut stream: TcpStream, req: RpcMsgReq) -> Result<(), MakerError> {
     stream.set_read_timeout(Some(Duration::from_secs(20)))?;
     stream.set_write_timeout(Some(Duration::from_secs(20)))?;
 
@@ -116,7 +128,7 @@ fn send_rpc_req(req: &RpcMsgReq) -> Result<(), MakerError> {
     let response_bytes = read_message(&mut stream)?;
     let response: RpcMsgResp = serde_cbor::from_slice(&response_bytes)?;
 
-    println!("{:?}", response);
+    println!("{}", response);
 
     Ok(())
 }

src/bin/makerd.rs

@@ -16,7 +16,7 @@ use std::{path::PathBuf, str::FromStr, sync::Arc};
 author = option_env ! ("CARGO_PKG_AUTHORS").unwrap_or(""))]
 struct Cli {
     /// Optional Connection Network Type
-    #[clap(long, default_value = "clearnet", possible_values = &["tor", "clearnet"])]
+    #[clap(long, default_value = "tor", possible_values = &["tor", "clearnet"])]
     network: String,
     /// Optional DNS data directory. Default value : "~/.coinswap/maker"
     #[clap(long, short = 'd')]

src/maker/api.rs

@@ -166,6 +166,8 @@ pub struct Maker {
     pub highest_fidelity_proof: RwLock<Option<FidelityProof>>,
     /// Is setup complete
     pub is_setup_complete: AtomicBool,
+    /// Path for the data directory.
+    pub data_dir: PathBuf,
     /// Thread pool for managing all spawned threads
     pub thread_pool: Arc<ThreadPool>,
 }
@@ -201,15 +203,7 @@ impl Maker {
         };
 
         // Get provided data directory or the default data directory.
-        let data_dir = if cfg!(feature = "integration-test") {
-            // We only append port number in data-dir for integration test
-            let port = port.expect("port value expected in Int tests");
-            data_dir.map_or(get_maker_dir().join(port.to_string()), |d| {
-                d.join("maker").join(port.to_string())
-            })
-        } else {
-            data_dir.unwrap_or(get_maker_dir())
-        };
+        let data_dir = data_dir.unwrap_or(get_maker_dir());
 
         let wallet_dir = data_dir.join("wallets");
 
@@ -284,10 +278,15 @@ impl Maker {
             connection_state: Mutex::new(HashMap::new()),
             highest_fidelity_proof: RwLock::new(None),
             is_setup_complete: AtomicBool::new(false),
+            data_dir,
             thread_pool: Arc::new(ThreadPool::new(thread_pool_port)),
         })
     }
 
+    pub fn get_data_dir(&self) -> &PathBuf {
+        &self.data_dir
+    }
+
     /// Returns a reference to the Maker's wallet.
     pub fn get_wallet(&self) -> &RwLock<Wallet> {
         &self.wallet

src/maker/config.rs

@@ -43,7 +43,7 @@ impl Default for MakerConfig {
             time_relative_fee_ppb: Amount::from_sat(100_000),
             min_size: 10_000,
             socks_port: 19050,
-            directory_server_address: "directoryhiddenserviceaddress.onion:8080".to_string(),
+            directory_server_address: "127.0.0.1:8080".to_string(),
             fidelity_value: 5_000_000, // 5 million sats
             fidelity_timelock: 26_000, // Approx 6 months of blocks
             connection_type: ConnectionType::TOR,

src/maker/rpc/messages.rs

@@ -1,6 +1,8 @@
+use std::fmt::Display;
+
 use bitcoind::bitcoincore_rpc::json::ListUnspentResultEntry;
 use serde::{Deserialize, Serialize};
-
+use std::path::PathBuf;
 #[derive(Serialize, Deserialize, Debug)]
 pub enum RpcMsgReq {
     Ping,
@@ -20,6 +22,7 @@ pub enum RpcMsgReq {
     },
     GetTorAddress,
     GetDataDir,
+    Stop,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -36,5 +39,27 @@ pub enum RpcMsgResp {
     NewAddressResp(String),
     SendToAddressResp(String),
     GetTorAddressResp(String),
-    GetDataDirResp(String),
+    GetDataDirResp(PathBuf),
+    Shutdown,
+}
+
+impl Display for RpcMsgResp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Pong => write!(f, "Pong"),
+            Self::NewAddressResp(addr) => write!(f, "{}", addr),
+            Self::SeedBalanceResp(bal) => write!(f, "{} sats", bal),
+            Self::ContractBalanceResp(bal) => write!(f, "{} sats", bal),
+            Self::SwapBalanceResp(bal) => write!(f, "{} sats", bal),
+            Self::FidelityBalanceResp(bal) => write!(f, "{} sats", bal),
+            Self::SeedUtxoResp { utxos } => write!(f, "{:?}", utxos),
+            Self::SwapUtxoResp { utxos } => write!(f, "{:?}", utxos),
+            Self::FidelityUtxoResp { utxos } => write!(f, "{:?}", utxos),
+            Self::ContractUtxoResp { utxos } => write!(f, "{:?}", utxos),
+            Self::SendToAddressResp(tx_hex) => write!(f, "{}", tx_hex),
+            Self::GetTorAddressResp(addr) => write!(f, "{}", addr),
+            Self::GetDataDirResp(path) => write!(f, "{}", path.display()),
+            Self::Shutdown => write!(f, "Shutdown Initiated"),
+        }
+    }
 }

src/maker/rpc/server.rs

@@ -1,5 +1,6 @@
 use std::{
-    io::ErrorKind,
+    fs::File,
+    io::{ErrorKind, Read},
     net::{TcpListener, TcpStream},
     sync::{atomic::Ordering::Relaxed, Arc},
     thread::sleep,
@@ -10,7 +11,7 @@ use bitcoin::{Address, Amount};
 
 use crate::{
     maker::{error::MakerError, rpc::messages::RpcMsgResp, Maker},
-    utill::{get_maker_dir, get_tor_addrs, read_message, send_message},
+    utill::{read_message, send_message, ConnectionType},
     wallet::{Destination, SendAmount},
 };
 use std::str::FromStr;
@@ -144,16 +145,36 @@ fn handle_request(maker: &Arc<Maker>, socket: &mut TcpStream) -> Result<(), Make
             };
         }
         RpcMsgReq::GetDataDir => {
-            let path = get_maker_dir().display().to_string();
-            let resp = RpcMsgResp::GetDataDirResp(path);
+            let path = maker.get_data_dir();
+            let resp = RpcMsgResp::GetDataDirResp(path.clone());
             if let Err(e) = send_message(socket, &resp) {
                 log::info!("Error sending RPC response {:?}", e);
             };
         }
         RpcMsgReq::GetTorAddress => {
-            let path = get_maker_dir().join("tor");
-            let resp = RpcMsgResp::GetTorAddressResp(get_tor_addrs(&path)?);
-            if let Err(e) = send_message(socket, &resp) {
+            if maker.config.connection_type == ConnectionType::CLEARNET {
+                let resp = RpcMsgResp::GetTorAddressResp("Maker is not running on TOR".to_string());
+                if let Err(e) = send_message(socket, &resp) {
+                    log::info!("Error sending RPC response {:?}", e);
+                };
+            } else {
+                let maker_hs_path_str =
+                    format!("/tmp/tor-rust-maker{}/hs-dir/hostname", maker.config.port);
+                let mut maker_file = File::open(maker_hs_path_str)?;
+                let mut maker_onion_addr: String = String::new();
+                maker_file.read_to_string(&mut maker_onion_addr)?;
+                maker_onion_addr.pop(); // Remove `\n` at the end.
+                let maker_address = format!("{}:{}", maker_onion_addr, maker.config.port);
+
+                let resp = RpcMsgResp::GetTorAddressResp(maker_address);
+                if let Err(e) = send_message(socket, &resp) {
+                    log::info!("Error sending RPC response {:?}", e);
+                };
+            }
+        }
+        RpcMsgReq::Stop => {
+            maker.shutdown.store(true, Relaxed);
+            if let Err(e) = send_message(socket, &RpcMsgResp::Shutdown) {
                 log::info!("Error sending RPC response {:?}", e);
             };
         }