Docs & Enclave initialization

packages/ciphernode/Cargo.toml

@@ -51,6 +51,7 @@ num = "0.4.3"
 rand_chacha = "0.3.1"
 rand = "0.8.5"
 serde = { version = "1.0.208", features = ["derive"] }
+serde_json = { version = "1.0.133" }
 sled = "0.34.7"
 sha2 = "0.10.8"
 tokio = { version = "1.38", features = ["full"] }

packages/ciphernode/cipher/src/password_manager.rs

@@ -14,6 +14,7 @@ pub trait PasswordManager {
     async fn get_key(&self) -> Result<Zeroizing<Vec<u8>>>;
     async fn delete_key(&mut self) -> Result<()>;
     async fn set_key(&mut self, contents: Zeroizing<Vec<u8>>) -> Result<()>;
+    fn is_set(&self) -> bool;
 }
 
 pub struct InMemPasswordManager(pub Option<Zeroizing<Vec<u8>>>);
@@ -54,6 +55,10 @@ impl PasswordManager for EnvPasswordManager {
         self.0 = None;
         Ok(())
     }
+
+    fn is_set(&self) -> bool {
+        self.0.is_some()
+    }
 }
 
 #[async_trait]
@@ -73,6 +78,10 @@ impl PasswordManager for InMemPasswordManager {
         self.0 = None;
         Ok(())
     }
+
+    fn is_set(&self) -> bool {
+        self.0.is_some()
+    }
 }
 
 pub struct FilePasswordManager {
@@ -149,6 +158,11 @@ impl PasswordManager for FilePasswordManager {
 
         Ok(())
     }
+
+    fn is_set(&self) -> bool {
+        let path = &self.path;
+        path.exists()
+    }
 }
 
 fn ensure_file_permissions(path: &PathBuf, perms: u32) -> Result<()> {

packages/ciphernode/config/Cargo.toml

@@ -9,3 +9,5 @@ anyhow = { workspace = true }
 serde = { workspace = true }
 figment = { workspace = true }
 alloy = { workspace = true }
+url = { workspace = true }
+

packages/ciphernode/config/src/app_config.rs

@@ -1,4 +1,7 @@
 use alloy::primitives::Address;
+use anyhow::anyhow;
+use anyhow::bail;
+use anyhow::Context;
 use anyhow::Result;
 use figment::{
     providers::{Format, Serialized, Yaml},
@@ -9,6 +12,7 @@ use std::{
     env,
     path::{Path, PathBuf},
 };
+use url::Url;
 
 #[derive(Debug, Deserialize, Serialize, PartialEq)]
 #[serde(untagged)]
@@ -20,6 +24,63 @@ pub enum Contract {
     AddressOnly(String),
 }
 
+#[derive(Clone)]
+pub enum RPC {
+    Http(String),
+    Https(String),
+    Ws(String),
+    Wss(String),
+}
+
+impl RPC {
+    pub fn from_url(url: &str) -> Result<Self> {
+        let parsed = Url::parse(url).context("Invalid URL format")?;
+        match parsed.scheme() {
+            "http" => Ok(RPC::Http(url.to_string())),
+            "https" => Ok(RPC::Https(url.to_string())),
+            "ws" => Ok(RPC::Ws(url.to_string())),
+            "wss" => Ok(RPC::Wss(url.to_string())),
+            _ => bail!("Invalid protocol. Expected: http://, https://, ws://, wss://"),
+        }
+    }
+
+    pub fn as_http_url(&self) -> Result<String> {
+        match self {
+            RPC::Http(url) | RPC::Https(url) => Ok(url.clone()),
+            RPC::Ws(url) | RPC::Wss(url) => {
+                let mut parsed =
+                    Url::parse(url).context(format!("Failed to parse URL: {}", url))?;
+                parsed
+                    .set_scheme(if self.is_secure() { "https" } else { "http" })
+                    .map_err(|_| anyhow!("http(s) are valid schemes"))?;
+                Ok(parsed.to_string())
+            }
+        }
+    }
+
+    pub fn as_ws_url(&self) -> Result<String> {
+        match self {
+            RPC::Ws(url) | RPC::Wss(url) => Ok(url.clone()),
+            RPC::Http(url) | RPC::Https(url) => {
+                let mut parsed =
+                    Url::parse(url).context(format!("Failed to parse URL: {}", url))?;
+                parsed
+                    .set_scheme(if self.is_secure() { "wss" } else { "ws" })
+                    .map_err(|_| anyhow!("ws(s) are valid schemes"))?;
+                Ok(parsed.to_string())
+            }
+        }
+    }
+
+    pub fn is_websocket(&self) -> bool {
+        matches!(self, RPC::Ws(_) | RPC::Wss(_))
+    }
+
+    pub fn is_secure(&self) -> bool {
+        matches!(self, RPC::Https(_) | RPC::Wss(_))
+    }
+}
+
 impl Contract {
     pub fn address(&self) -> &String {
         use Contract::*;
@@ -63,12 +124,19 @@ impl Default for RpcAuth {
 pub struct ChainConfig {
     pub enabled: Option<bool>,
     pub name: String,
-    pub rpc_url: String, // We may need multiple per chain for redundancy at a later point
+    rpc_url: String, // We may need multiple per chain for redundancy at a later point
     #[serde(default)]
     pub rpc_auth: RpcAuth,
     pub contracts: ContractAddresses,
 }
 
+impl ChainConfig {
+    pub fn rpc_url(&self) -> Result<RPC> {
+        Ok(RPC::from_url(&self.rpc_url)
+            .map_err(|e| anyhow!("Failed to parse RPC URL for chain {}: {}", self.name, e))?)
+    }
+}
+
 #[derive(Debug, Deserialize, Serialize)]
 pub struct AppConfig {
     /// The chains config
@@ -254,10 +322,12 @@ fn expand_tilde(path: &Path) -> PathBuf {
 struct OsDirs;
 impl OsDirs {
     pub fn config_dir() -> PathBuf {
+        // TODO: handle unwrap error case
         dirs::config_dir().unwrap().join("enclave")
     }
 
     pub fn data_dir() -> PathBuf {
+        // TODO: handle unwrap error case
         dirs::data_local_dir().unwrap().join("enclave")
     }
 }