From ecdb3ee944f5c171faac3a71117e2ff27e064295 Mon Sep 17 00:00:00 2001
From: tv <tv@krebsco.de>
Date: Mon, 26 Oct 2026 21:48:54 +0100
Subject: turn all pub into pub(crate)

---
 src/transport/mycelium/daemon.rs | 50 ++++++++++++++++++++--------------------
 src/transport/mycelium/mod.rs    | 14 +++++------
 2 files changed, 32 insertions(+), 32 deletions(-)

(limited to 'src/transport/mycelium')

diff --git a/src/transport/mycelium/daemon.rs b/src/transport/mycelium/daemon.rs
index f194fca..f986d52 100644
--- a/src/transport/mycelium/daemon.rs
+++ b/src/transport/mycelium/daemon.rs
@@ -14,28 +14,28 @@ use url::Url;
 
 /// Represents where a 32-byte cryptographic key originates.
 #[derive(Debug, Clone)]
-pub enum KeySource {
+pub(crate) enum KeySource {
     Raw([u8; 32]),
     Path(PathBuf),
 }
 
 /// Atomic structure ensuring private network credentials are always handled together.
 #[derive(Debug, Clone)]
-pub struct PrivateNetworkConfig {
-    pub name: String,
-    pub key: KeySource,
+pub(crate) struct PrivateNetworkConfig {
+    pub(crate) name: String,
+    pub(crate) key: KeySource,
 }
 
 /// Comprehensive parameters required to spawn or target an instance.
 #[derive(Debug, Clone)]
-pub struct MyceliumSpawnConfig {
-    pub rest_url_opt: Option<Url>,
-    pub key_file_opt: Option<PathBuf>,
-    pub network_key_file: Option<PathBuf>,
+pub(crate) struct MyceliumSpawnConfig {
+    pub(crate) rest_url_opt: Option<Url>,
+    pub(crate) key_file_opt: Option<PathBuf>,
+    pub(crate) network_key_file: Option<PathBuf>,
     /// Set together with `network_key_file` (`Settings::check`).
-    pub network_name: Option<String>,
-    pub tcp_port: Option<u16>,
-    pub peers: Vec<String>,
+    pub(crate) network_name: Option<String>,
+    pub(crate) tcp_port: Option<u16>,
+    pub(crate) peers: Vec<String>,
 }
 
 impl Default for MyceliumSpawnConfig {
@@ -51,19 +51,19 @@ impl Default for MyceliumSpawnConfig {
     }
 }
 
-pub enum MyceliumRuntime {
+pub(crate) enum MyceliumRuntime {
     Supervised(Box<SupervisedMycelium>),
     External,
 }
 
-pub struct MyceliumSetup {
-    pub runtime: MyceliumRuntime,
-    pub rest_url: Url,
+pub(crate) struct MyceliumSetup {
+    pub(crate) runtime: MyceliumRuntime,
+    pub(crate) rest_url: Url,
 }
 
 impl MyceliumSetup {
     /// Evaluates the configuration payload and initializes the chosen execution strategy.
-    pub async fn bootstrap(config: MyceliumSpawnConfig) -> Result<Self> {
+    pub(crate) async fn bootstrap(config: MyceliumSpawnConfig) -> Result<Self> {
         // TODO warn for all ignored options if rest_url_opt is set
         if let Some(url) = config.rest_url_opt {
             tracing::info!(
@@ -115,7 +115,7 @@ impl MyceliumSetup {
     }
 
     /// Blocks until the background daemon drops out. If running externally, hangs open indefinitely.
-    pub async fn wait_for_exit(&mut self) -> std::io::Result<std::process::ExitStatus> {
+    pub(crate) async fn wait_for_exit(&mut self) -> std::io::Result<std::process::ExitStatus> {
         match &mut self.runtime {
             MyceliumRuntime::Supervised(node) => node.wait_for_exit().await,
             MyceliumRuntime::External => {
@@ -126,16 +126,16 @@ impl MyceliumSetup {
 }
 
 #[derive(Debug, Clone)]
-pub struct MyceliumNodeConfig {
-    pub tcp_port: u16,
-    pub api_port: u16,
-    pub rpc_port: u16,
-    pub private_network: Option<String>,
+pub(crate) struct MyceliumNodeConfig {
+    pub(crate) tcp_port: u16,
+    pub(crate) api_port: u16,
+    pub(crate) rpc_port: u16,
+    pub(crate) private_network: Option<String>,
 }
 
-pub struct SupervisedMycelium {
+pub(crate) struct SupervisedMycelium {
     child: Child,
-    pub config: MyceliumNodeConfig,
+    pub(crate) config: MyceliumNodeConfig,
     _key_file_handle: Option<File>,
     _net_key_file_handle: Option<File>,
 }
@@ -327,7 +327,7 @@ impl SupervisedMycelium {
         }
     }
 
-    pub async fn wait_for_exit(&mut self) -> std::io::Result<std::process::ExitStatus> {
+    pub(crate) async fn wait_for_exit(&mut self) -> std::io::Result<std::process::ExitStatus> {
         self.child.wait().await
     }
 }
diff --git a/src/transport/mycelium/mod.rs b/src/transport/mycelium/mod.rs
index 5062d4a..6304819 100644
--- a/src/transport/mycelium/mod.rs
+++ b/src/transport/mycelium/mod.rs
@@ -10,9 +10,9 @@ use url::Url;
 use crate::transport::wire;
 use crate::transport::{EncodedMessage, MessageHandler, ParsedMessage, Transport};
 
-pub mod daemon;
+pub(crate) mod daemon;
 
-pub use daemon::{MyceliumSetup, MyceliumSpawnConfig};
+pub(crate) use daemon::{MyceliumSetup, MyceliumSpawnConfig};
 
 const MYCELIUM_POLL_TIMEOUT_SECS: u64 = 300;
 /// The largest inbound message read (its JSON, base64 payload included: about 190 MiB of
@@ -64,15 +64,15 @@ struct Destination {
 /// The part of Mycelium's `/api/v1/admin` answer we use.
 #[derive(Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
-pub struct MyceliumAdminInfo {
-    pub node_pubkey: String,
+pub(crate) struct MyceliumAdminInfo {
+    pub(crate) node_pubkey: String,
 }
 
 fn is_pubkey(s: &str) -> bool {
     s.len() == 64 && s.chars().all(|c| c.is_ascii_hexdigit())
 }
 
-pub struct MyceliumTransport {
+pub(crate) struct MyceliumTransport {
     /// The daemon, kept to wait for its exit.
     setup: tokio::sync::Mutex<MyceliumSetup>,
     client: reqwest::Client,
@@ -84,7 +84,7 @@ pub struct MyceliumTransport {
 }
 
 impl MyceliumTransport {
-    pub async fn connect(setup: MyceliumSetup) -> Result<Self> {
+    pub(crate) async fn connect(setup: MyceliumSetup) -> Result<Self> {
         let rest_url = setup.rest_url.clone();
 
         let client = reqwest::Client::builder()
@@ -515,7 +515,7 @@ fn format_message(
 }
 
 #[derive(Error, Debug)]
-pub enum TransportError {
+pub(crate) enum TransportError {
     #[error("Mycelium delivered a message without a sender public key")]
     NoSender,
 
-- 
cgit v1.3.1