Merge pull request #4 from LayerTwo-Labs/2025-02-13-backport-thunder-0.11.3

Backport Thunder 0.11.3

Author: Ash-L2L

Cargo.lock

@@ -8,6 +8,13 @@ members = [
     "rpc-api",
 ]
 
+[workspace.package]
+authors = [ "Ash Manning <ash@layertwolabs.com>" ]
+edition = "2021"
+license-file = "LICENSE.txt"
+publish = false
+version = "0.11.3"
+
 [workspace.dependencies]
 anyhow = "1.0.72"
 bincode = "1.3.3"
@@ -33,6 +40,7 @@ tokio-util = "0.7.10"
 tonic = "0.12.3"
 tracing = "0.1.40"
 tracing-subscriber = "0.3.18"
+url = "2.5.4"
 utoipa = { version = "5.2.0", default-features = false }
 
 [workspace.dependencies.bip300301_enforcer_lib]
@@ -61,13 +69,6 @@ wildcard_imports = "deny"
 [workspace.lints.rust]
 let_underscore_drop = "deny"
 
-[workspace.package]
-authors = [ "Ash Manning <ash@layertwolabs.com>" ]
-edition = "2021"
-license-file = "LICENSE.txt"
-publish = false
-version = "0.11.2"
-
 # temp-dir does not leak correctly after clone
 # https://gitlab.com/leonhard-llc/ops/-/issues/17
 [patch.crates-io.temp-dir]

Cargo.toml

@@ -40,6 +40,7 @@ tonic-health = "0.12.3"
 tracing = { workspace = true }
 tracing-appender = "0.2.3"
 tracing-subscriber = { workspace = true, features = ["env-filter", "json"] }
+url = { workspace = true }
 utoipa = { workspace = true }
 
 [dependencies.libes]

app/Cargo.toml

@@ -42,10 +42,10 @@ pub enum Error {
     #[error(transparent)]
     Other(#[from] anyhow::Error),
     #[error(
-        "Unable to verify existence of CUSF mainchain service(s) at {address}"
+        "Unable to verify existence of CUSF mainchain service(s) at {url}"
     )]
     VerifyMainchainServices {
-        address: std::net::SocketAddr,
+        url: url::Url,
         source: tonic::Status,
     },
     #[error("wallet error")]
@@ -217,18 +217,21 @@ impl App {
             let mnemonic = std::fs::read_to_string(seed_phrase_path)?;
             let () = wallet.set_seed_from_mnemonic(mnemonic.as_str())?;
         }
-        tracing::info!("Connecting to mainchain at {}", config.main_addr);
+        tracing::info!(
+            url = %config.mainchain_grpc_url,
+            "Connecting to mainchain"
+        );
         let rt_guard = runtime.enter();
         let transport = tonic::transport::channel::Channel::from_shared(
-            format!("https://{}", config.main_addr),
+            config.mainchain_grpc_url.to_string(),
         )
         .unwrap()
         .concurrency_limit(256)
         .connect_lazy();
         let (cusf_mainchain, cusf_mainchain_wallet) = if runtime
             .block_on(Self::check_proto_support(transport.clone()))
             .map_err(|err| Error::VerifyMainchainServices {
-                address: config.main_addr,
+                url: config.mainchain_grpc_url.clone(),
                 source: err,
             })? {
             (

app/app.rs

@@ -7,6 +7,7 @@ use std::{
 
 use clap::{Arg, Parser};
 use plain_bitassets::types::{Network, THIS_SIDECHAIN};
+use url::{Host, Url};
 
 const fn ipv4_socket_addr(ipv4_octets: [u8; 4], port: u16) -> SocketAddr {
     let [a, b, c, d] = ipv4_octets;
@@ -23,7 +24,9 @@ static DEFAULT_DATA_DIR: LazyLock<Option<PathBuf>> =
         Some(data_dir) => Some(data_dir.join("plain_bitassets")),
     });
 
-const DEFAULT_MAIN_ADDR: SocketAddr = ipv4_socket_addr([127, 0, 0, 1], 50051);
+const DEFAULT_MAIN_HOST: Host = Host::Ipv4(Ipv4Addr::LOCALHOST);
+
+const DEFAULT_MAIN_PORT: u16 = 50051;
 
 const DEFAULT_NET_ADDR: SocketAddr =
     ipv4_socket_addr([0, 0, 0, 0], 4000 + THIS_SIDECHAIN as u16);
@@ -121,9 +124,12 @@ pub(super) struct Cli {
     /// Log level
     #[arg(default_value_t = tracing::Level::DEBUG, long)]
     log_level: tracing::Level,
-    /// Socket address to connect to mainchain node gRPC server
-    #[arg(default_value_t = DEFAULT_MAIN_ADDR, long, short)]
-    main_addr: SocketAddr,
+    /// Connect to mainchain node gRPC server running on this host/port
+    #[arg(default_value_t = DEFAULT_MAIN_HOST, long, value_parser = Host::parse)]
+    mainchain_grpc_host: Host,
+    /// Connect to mainchain node gRPC server running on this host/port
+    #[arg(default_value_t = DEFAULT_MAIN_PORT, long)]
+    mainchain_grpc_port: u16,
     /// Path to a mnemonic seed phrase
     #[arg(long)]
     mnemonic_seed_phrase_path: Option<PathBuf>,
@@ -142,25 +148,17 @@ pub(super) struct Cli {
     pub zmq_addr: SocketAddr,
 }
 
-#[derive(Clone, Debug)]
-pub struct Config {
-    pub datadir: PathBuf,
-    pub file_log_level: tracing::Level,
-    pub headless: bool,
-    /// If None, logging to file should be disabled.
-    pub log_dir: Option<PathBuf>,
-    pub log_level: tracing::Level,
-    pub main_addr: SocketAddr,
-    pub mnemonic_seed_phrase_path: Option<PathBuf>,
-    pub net_addr: SocketAddr,
-    pub network: Network,
-    pub rpc_addr: SocketAddr,
-    #[cfg(feature = "zmq")]
-    pub zmq_addr: SocketAddr,
-}
-
 impl Cli {
+    pub fn mainchain_grpc_url(&self) -> Url {
+        Url::parse(&format!(
+            "http://{}:{}",
+            self.mainchain_grpc_host, self.mainchain_grpc_port
+        ))
+        .unwrap()
+    }
+
     pub fn get_config(self) -> anyhow::Result<Config> {
+        let mainchain_grpc_url = self.mainchain_grpc_url();
         let log_dir = match self.log_dir {
             None => {
                 let version_dir_name =
@@ -183,7 +181,7 @@ impl Cli {
             headless: self.headless,
             log_dir,
             log_level: self.log_level,
-            main_addr: self.main_addr,
+            mainchain_grpc_url,
             mnemonic_seed_phrase_path: self.mnemonic_seed_phrase_path,
             net_addr: self.net_addr,
             network: self.network,
@@ -193,3 +191,20 @@ impl Cli {
         })
     }
 }
+
+#[derive(Clone, Debug)]
+pub struct Config {
+    pub datadir: PathBuf,
+    pub file_log_level: tracing::Level,
+    pub headless: bool,
+    /// If None, logging to file should be disabled.
+    pub log_dir: Option<PathBuf>,
+    pub log_level: tracing::Level,
+    pub mainchain_grpc_url: url::Url,
+    pub mnemonic_seed_phrase_path: Option<PathBuf>,
+    pub net_addr: SocketAddr,
+    pub network: Network,
+    pub rpc_addr: SocketAddr,
+    #[cfg(feature = "zmq")]
+    pub zmq_addr: SocketAddr,
+}

app/cli.rs

@@ -1,9 +1,6 @@
-use std::{
-    net::SocketAddr,
-    sync::{
-        atomic::{self, AtomicBool},
-        Arc,
-    },
+use std::sync::{
+    atomic::{self, AtomicBool},
+    Arc,
 };
 
 use clap::Parser;
@@ -32,16 +29,16 @@ pub struct ConsoleCommand {
 pub struct ConsoleLogs {
     line_buffer: LineBuffer,
     command_input: String,
-    rpc_addr: SocketAddr,
+    rpc_url: url::Url,
     running_command: Arc<AtomicBool>,
 }
 
 impl ConsoleLogs {
-    pub fn new(line_buffer: LineBuffer, rpc_addr: SocketAddr) -> Self {
+    pub fn new(line_buffer: LineBuffer, rpc_url: url::Url) -> Self {
         Self {
             line_buffer,
             command_input: String::new(),
-            rpc_addr,
+            rpc_url,
             running_command: Arc::new(AtomicBool::new(false)),
         }
     }
@@ -70,8 +67,11 @@ impl ConsoleLogs {
                 return;
             }
         };
-        let cli =
-            plain_bitassets_app_cli_lib::Cli::new(command, self.rpc_addr, None);
+        let cli = plain_bitassets_app_cli_lib::Cli::new(
+            command,
+            self.rpc_url.clone(),
+            None,
+        );
         app.runtime.spawn({
             let running_command = self.running_command.clone();
             running_command.store(true, atomic::Ordering::SeqCst);

app/gui/console_logs.rs

@@ -1,4 +1,4 @@
-use std::{net::SocketAddr, task::Poll};
+use std::task::Poll;
 
 use eframe::egui::{self, Color32, RichText};
 use plain_bitassets::{util::Watchable, wallet::Wallet};
@@ -190,7 +190,7 @@ impl EguiApp {
         app: Option<App>,
         cc: &eframe::CreationContext<'_>,
         logs_capture: LineBuffer,
-        rpc_addr: SocketAddr,
+        rpc_addr: url::Url,
     ) -> Self {
         // Customize egui here with cc.egui_ctx.set_fonts and cc.egui_ctx.set_visuals.
         // Restore app state using cc.storage (requires the "persistence" feature).

app/gui/mod.rs

@@ -144,16 +144,13 @@ fn run_egui_app(
     app: Option<crate::app::App>,
 ) -> Result<(), eframe::Error> {
     let native_options = eframe::NativeOptions::default();
+    let rpc_addr = url::Url::parse(&format!("http://{}", config.rpc_addr))
+        .expect("failed to parse rpc addr");
     eframe::run_native(
         "Plain Bitassets",
         native_options,
         Box::new(move |cc| {
-            Ok(Box::new(gui::EguiApp::new(
-                app,
-                cc,
-                line_buffer,
-                config.rpc_addr,
-            )))
+            Ok(Box::new(gui::EguiApp::new(app, cc, line_buffer, rpc_addr)))
         }),
     )
 }

app/main.rs

@@ -15,6 +15,7 @@ plain_bitassets = { path = "../lib", features = ["clap"] }
 plain_bitassets_app_rpc_api = { path = "../rpc-api" }
 serde_json = { workspace = true }
 tokio = { workspace = true }
+url = { workspace = true }
 utoipa = { workspace = true }
 
 [lib]
@@ -23,4 +24,4 @@ path = "lib.rs"
 
 [[bin]]
 name = "plain_bitassets_app_cli"
-path = "main.rs"
+path = "main.rs"

cli/Cargo.toml

@@ -1,5 +1,6 @@
 use std::{
     net::{IpAddr, Ipv4Addr, SocketAddr},
+    sync::LazyLock,
     time::Duration,
 };
 
@@ -10,6 +11,7 @@ use plain_bitassets::types::{
     DutchAuctionParams, THIS_SIDECHAIN,
 };
 use plain_bitassets_app_rpc_api::RpcClient;
+use url::Url;
 
 #[derive(Clone, Debug, Subcommand)]
 #[command(arg_required_else_help(true))]
@@ -152,16 +154,20 @@ const DEFAULT_RPC_ADDR: SocketAddr = SocketAddr::new(
     6000 + THIS_SIDECHAIN as u16,
 );
 
+static DEFAULT_RPC_URL: LazyLock<Url> = LazyLock::new(|| {
+    Url::parse(&format!("http://{DEFAULT_RPC_ADDR}")).unwrap()
+});
+
 const DEFAULT_TIMEOUT_SECS: u64 = 60;
 
 #[derive(Clone, Debug, Parser)]
 #[command(author, version, about, long_about = None)]
 pub struct Cli {
     #[command(subcommand)]
     pub command: Command,
-    /// address for use by the RPC server
-    #[arg(default_value_t = DEFAULT_RPC_ADDR, long)]
-    pub rpc_addr: SocketAddr,
+    /// Base URL used for requests to the RPC server.
+    #[arg(default_value_t = DEFAULT_RPC_URL.clone(), long)]
+    pub rpc_url: Url,
     /// Timeout for RPC requests in seconds.
     #[arg(default_value_t = DEFAULT_TIMEOUT_SECS, long = "timeout")]
     timeout_secs: u64,
@@ -170,12 +176,12 @@ pub struct Cli {
 impl Cli {
     pub fn new(
         command: Command,
-        rpc_addr: SocketAddr,
+        rpc_url: Url,
         timeout_secs: Option<u64>,
     ) -> Self {
         Self {
             command,
-            rpc_addr,
+            rpc_url,
             timeout_secs: timeout_secs.unwrap_or(DEFAULT_TIMEOUT_SECS),
         }
     }
@@ -185,7 +191,7 @@ impl Cli {
     pub async fn run(self) -> anyhow::Result<String> {
         let rpc_client: HttpClient = HttpClientBuilder::default()
             .request_timeout(Duration::from_secs(self.timeout_secs))
-            .build(format!("http://{}", self.rpc_addr))?;
+            .build(self.rpc_url)?;
         let res = match self.command {
             Command::AmmBurn {
                 asset0,