Remove cdk-database

Cargo.lock

@@ -922,16 +922,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "cdk-database"
-version = "0.6.1"
-dependencies = [
- "cdk-common",
- "cdk-redb",
- "cdk-sqlite",
- "serde",
-]
-
-[[package]]
 name = "cdk-fake-wallet"
 version = "0.6.0"
 dependencies = [
@@ -1024,12 +1014,13 @@ dependencies = [
  "cdk",
  "cdk-axum",
  "cdk-cln",
- "cdk-database",
  "cdk-fake-wallet",
  "cdk-lnbits",
  "cdk-lnd",
  "cdk-phoenixd",
+ "cdk-redb",
  "cdk-signatory",
+ "cdk-sqlite",
  "cdk-strike",
  "clap",
  "config",

crates/cdk-database/Cargo.toml

@@ -1,16 +0,0 @@
-[package]
-name = "cdk-database"
-version = "0.6.1"
-edition = "2021"
-description = "CDK database"
-
-[features]
-mint = ["cdk-sqlite/mint", "cdk-redb/mint"]
-wallet = ["cdk-sqlite/wallet", "cdk-redb/wallet"]
-default = ["mint", "wallet"]
-
-[dependencies]
-cdk-common = { path = "../cdk-common" }
-cdk-sqlite = { path = "../cdk-sqlite", default-features = false }
-cdk-redb = { path = "../cdk-redb", default-features = false }
-serde = { version = "1.0.217", features = ["derive"] }

crates/cdk-database/src/lib.rs

@@ -1,57 +0,0 @@
-//! Common types for the CDK CLI
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use cdk_redb::MintRedbDatabase;
-use cdk_sqlite::MintSqliteDatabase;
-use serde::{Deserialize, Serialize};
-
-/// Database engine definition
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default)]
-#[serde(rename_all = "lowercase")]
-pub enum DatabaseEngine {
-    #[default]
-    Sqlite,
-    Redb,
-}
-
-impl std::str::FromStr for DatabaseEngine {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_lowercase().as_str() {
-            "sqlite" => Ok(DatabaseEngine::Sqlite),
-            "redb" => Ok(DatabaseEngine::Redb),
-            _ => Err(format!("Unknown database engine: {}", s)),
-        }
-    }
-}
-
-impl DatabaseEngine {
-    /// Convert the database instance into a mint database
-    pub async fn mint<P: Into<PathBuf>>(
-        self,
-        work_dir: P,
-    ) -> Result<
-        Arc<
-            dyn cdk_common::database::MintDatabase<Err = cdk_common::database::Error>
-                + Sync
-                + Send
-                + 'static,
-        >,
-        cdk_common::database::Error,
-    > {
-        match self {
-            DatabaseEngine::Sqlite => {
-                let sql_db_path = work_dir.into().join("cdk-mintd.sqlite");
-                let db = MintSqliteDatabase::new(&sql_db_path).await?;
-                db.migrate().await;
-                Ok(Arc::new(db))
-            }
-            DatabaseEngine::Redb => {
-                let redb_path = work_dir.into().join("cdk-mintd.redb");
-                Ok(Arc::new(MintRedbDatabase::new(&redb_path)?))
-            }
-        }
-    }
-}

crates/cdk-mintd/Cargo.toml

@@ -15,10 +15,13 @@ axum = "0.6.20"
 cdk = { path = "../cdk", version = "0.6.0", default-features = false, features = [
     "mint",
 ] }
-cdk-cln = { path = "../cdk-cln", version = "0.6.0", default-features = false }
-cdk-database = { path = "../cdk-database", version = "0.6.0", default-features = false, features = [
+cdk-redb = { path = "../cdk-redb", version = "0.6.0", default-features = false, features = [
+    "mint",
+] }
+cdk-sqlite = { path = "../cdk-sqlite", version = "0.6.0", default-features = false, features = [
     "mint",
 ] }
+cdk-cln = { path = "../cdk-cln", version = "0.6.0", default-features = false }
 cdk-lnbits = { path = "../cdk-lnbits", version = "0.6.0", default-features = false }
 cdk-phoenixd = { path = "../cdk-phoenixd", version = "0.6.0", default-features = false }
 cdk-lnd = { path = "../cdk-lnd", version = "0.6.0", default-features = false }

crates/cdk-mintd/src/bin/signatory.rs

@@ -3,6 +3,7 @@ use std::env;
 use std::str::FromStr;
 
 use bip39::Mnemonic;
+use cdk::nuts::CurrencyUnit;
 use cdk_mintd::cli::CLIArgs;
 use cdk_mintd::env_vars::ENV_WORK_DIR;
 use cdk_mintd::{config, work_dir};
@@ -29,7 +30,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     };
 
     let settings = if config_file_arg.exists() {
-        config::Settings::new(Some(config_file_arg), false)
+        config::Settings::new(Some(config_file_arg))
     } else {
         tracing::info!("Config file does not exist. Attempting to read env vars");
         config::Settings::default()
@@ -37,7 +38,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // This check for any settings defined in ENV VARs
     // ENV VARS will take **priority** over those in the config
-    let mut settings = settings.from_env(false)?;
+    let mut settings = settings.from_env()?;
     let mnemonic = Mnemonic::from_str(&settings.info.mnemonic)?;
 
     let signatory = MemorySignatory::new(
@@ -46,7 +47,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         settings
             .supported_units
             .take()
-            .expect("No supported units defined")
+            .unwrap_or(vec![CurrencyUnit::default()])
             .into_iter()
             .map(|u| (u, (0, 32)))
             .collect::<HashMap<_, _>>(),

crates/cdk-mintd/src/config.rs

@@ -1,9 +1,12 @@
 use std::path::PathBuf;
+use std::sync::Arc;
 
+use cdk::cdk_database;
 use cdk::nuts::{CurrencyUnit, PublicKey};
 use cdk::Amount;
 use cdk_axum::cache;
-use cdk_database::DatabaseEngine;
+use cdk_redb::MintRedbDatabase;
+use cdk_sqlite::MintSqliteDatabase;
 use config::{Config, ConfigError, File};
 use serde::{Deserialize, Serialize};
 
@@ -150,6 +153,50 @@ fn default_max_delay_time() -> u64 {
     3
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum DatabaseEngine {
+    #[default]
+    Sqlite,
+    Redb,
+}
+
+impl std::str::FromStr for DatabaseEngine {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "sqlite" => Ok(DatabaseEngine::Sqlite),
+            "redb" => Ok(DatabaseEngine::Redb),
+            _ => Err(format!("Unknown database engine: {}", s)),
+        }
+    }
+}
+
+impl DatabaseEngine {
+    /// Convert the database instance into a mint database
+    pub async fn mint<P: Into<PathBuf>>(
+        self,
+        work_dir: P,
+    ) -> Result<
+        Arc<dyn cdk_database::MintDatabase<Err = cdk_database::Error> + Sync + Send + 'static>,
+        cdk_database::Error,
+    > {
+        match self {
+            DatabaseEngine::Sqlite => {
+                let sql_db_path = work_dir.into().join("cdk-mintd.sqlite");
+                let db = MintSqliteDatabase::new(&sql_db_path).await?;
+                db.migrate().await;
+                Ok(Arc::new(db))
+            }
+            DatabaseEngine::Redb => {
+                let redb_path = work_dir.into().join("cdk-mintd.redb");
+                Ok(Arc::new(MintRedbDatabase::new(&redb_path)?))
+            }
+        }
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct Database {
     pub engine: DatabaseEngine,
@@ -167,9 +214,9 @@ pub struct Settings {
     pub phoenixd: Option<Phoenixd>,
     pub lnd: Option<Lnd>,
     pub fake_wallet: Option<FakeWallet>,
+    pub database: Database,
     pub supported_units: Option<Vec<CurrencyUnit>>,
     pub remote_signatory: Option<String>,
-    pub database: Database,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
@@ -194,13 +241,13 @@ pub struct MintInfo {
 
 impl Settings {
     #[must_use]
-    pub fn new<P>(config_file_name: Option<P>, check_ln: bool) -> Self
+    pub fn new<P>(config_file_name: Option<P>) -> Self
     where
         P: Into<PathBuf>,
     {
         let default_settings = Self::default();
         // attempt to construct settings with file
-        let from_file = Self::new_from_default(&default_settings, config_file_name, check_ln);
+        let from_file = Self::new_from_default(&default_settings, config_file_name);
         match from_file {
             Ok(f) => f,
             Err(e) => {
@@ -213,7 +260,6 @@ impl Settings {
     fn new_from_default<P>(
         default: &Settings,
         config_file_name: Option<P>,
-        check_ln: bool,
     ) -> Result<Self, ConfigError>
     where
         P: Into<PathBuf>,
@@ -236,36 +282,34 @@ impl Settings {
             .build()?;
         let settings: Settings = config.try_deserialize()?;
 
-        if check_ln {
-            match settings.ln.ln_backend {
-                LnBackend::None => panic!("Ln backend must be set"),
-                LnBackend::Cln => assert!(
-                    settings.cln.is_some(),
-                    "CLN backend requires a valid config."
-                ),
-                LnBackend::Strike => assert!(
-                    settings.strike.is_some(),
-                    "Strike backend requires a valid config."
-                ),
-                LnBackend::LNbits => assert!(
-                    settings.lnbits.is_some(),
-                    "LNbits backend requires a valid config"
-                ),
-                LnBackend::Phoenixd => assert!(
-                    settings.phoenixd.is_some(),
-                    "Phoenixd backend requires a valid config"
-                ),
-                LnBackend::Lnd => {
-                    assert!(
-                        settings.lnd.is_some(),
-                        "LND backend requires a valid config."
-                    )
-                }
-                LnBackend::FakeWallet => assert!(
-                    settings.fake_wallet.is_some(),
-                    "FakeWallet backend requires a valid config."
-                ),
+        match settings.ln.ln_backend {
+            LnBackend::None => panic!("Ln backend must be set"),
+            LnBackend::Cln => assert!(
+                settings.cln.is_some(),
+                "CLN backend requires a valid config."
+            ),
+            LnBackend::Strike => assert!(
+                settings.strike.is_some(),
+                "Strike backend requires a valid config."
+            ),
+            LnBackend::LNbits => assert!(
+                settings.lnbits.is_some(),
+                "LNbits backend requires a valid config"
+            ),
+            LnBackend::Phoenixd => assert!(
+                settings.phoenixd.is_some(),
+                "Phoenixd backend requires a valid config"
+            ),
+            LnBackend::Lnd => {
+                assert!(
+                    settings.lnd.is_some(),
+                    "LND backend requires a valid config."
+                )
             }
+            LnBackend::FakeWallet => assert!(
+                settings.fake_wallet.is_some(),
+                "FakeWallet backend requires a valid config."
+            ),
         }
 
         Ok(settings)

crates/cdk-mintd/src/env_vars.rs

@@ -4,11 +4,10 @@ use std::str::FromStr;
 
 use anyhow::{anyhow, bail, Result};
 use cdk::nuts::CurrencyUnit;
-use cdk_database::DatabaseEngine;
 
 use crate::config::{
-    Cln, Database, FakeWallet, Info, LNbits, Ln, LnBackend, Lnd, MintInfo, Phoenixd, Settings,
-    Strike,
+    Cln, Database, DatabaseEngine, FakeWallet, Info, LNbits, Ln, LnBackend, Lnd, MintInfo,
+    Phoenixd, Settings, Strike,
 };
 
 pub const ENV_WORK_DIR: &str = "CDK_MINTD_WORK_DIR";
@@ -73,39 +72,36 @@ pub const ENV_FAKE_WALLET_MIN_DELAY: &str = "CDK_MINTD_FAKE_WALLET_MIN_DELAY";
 pub const ENV_FAKE_WALLET_MAX_DELAY: &str = "CDK_MINTD_FAKE_WALLET_MAX_DELAY";
 
 impl Settings {
-    pub fn from_env(mut self, check_ln: bool) -> Result<Self> {
+    pub fn from_env(mut self) -> Result<Self> {
         if let Ok(database) = env::var(DATABASE_ENV_VAR) {
             let engine = DatabaseEngine::from_str(&database).map_err(|err| anyhow!(err))?;
             self.database = Database { engine };
         }
 
-        self.info = self.info.clone().from_env();
-        self.mint_info = self.mint_info.clone().from_env();
-        self.ln = self.ln.clone().from_env();
-
-        if check_ln {
-            match self.ln.ln_backend {
-                LnBackend::Cln => {
-                    self.cln = Some(self.cln.clone().unwrap_or_default().from_env());
-                }
-                LnBackend::Strike => {
-                    self.strike = Some(self.strike.clone().unwrap_or_default().from_env());
-                }
-                LnBackend::LNbits => {
-                    self.lnbits = Some(self.lnbits.clone().unwrap_or_default().from_env());
-                }
-                LnBackend::FakeWallet => {
-                    self.fake_wallet =
-                        Some(self.fake_wallet.clone().unwrap_or_default().from_env());
-                }
-                LnBackend::Phoenixd => {
-                    self.phoenixd = Some(self.phoenixd.clone().unwrap_or_default().from_env());
-                }
-                LnBackend::Lnd => {
-                    self.lnd = Some(self.lnd.clone().unwrap_or_default().from_env());
-                }
-                LnBackend::None => bail!("Ln backend must be set"),
+        self.info = self.info.from_env();
+        self.mint_info = self.mint_info.from_env();
+        self.ln = self.ln.from_env();
+
+        match self.ln.ln_backend {
+            LnBackend::Cln => {
+                self.cln = Some(self.cln.clone().unwrap_or_default().from_env());
+            }
+            LnBackend::Strike => {
+                self.strike = Some(self.strike.clone().unwrap_or_default().from_env());
+            }
+            LnBackend::LNbits => {
+                self.lnbits = Some(self.lnbits.clone().unwrap_or_default().from_env());
+            }
+            LnBackend::FakeWallet => {
+                self.fake_wallet = Some(self.fake_wallet.clone().unwrap_or_default().from_env());
+            }
+            LnBackend::Phoenixd => {
+                self.phoenixd = Some(self.phoenixd.clone().unwrap_or_default().from_env());
+            }
+            LnBackend::Lnd => {
+                self.lnd = Some(self.lnd.clone().unwrap_or_default().from_env());
             }
+            LnBackend::None => bail!("Ln backend must be set"),
         }
 
         Ok(self)

crates/cdk-mintd/src/lib.rs

@@ -42,13 +42,10 @@ mod test {
 
     #[test]
     fn example_is_parsed() {
-        let config = config::Settings::new(
-            Some(format!(
-                "{}/example.config.toml",
-                current_dir().expect("cwd").to_string_lossy()
-            )),
-            true,
-        );
+        let config = config::Settings::new(Some(format!(
+            "{}/example.config.toml",
+            current_dir().expect("cwd").to_string_lossy()
+        )));
         let cache = config.info.http_cache;
 
         assert_eq!(cache.ttl, Some(60));

crates/cdk-mintd/src/main.rs

@@ -74,7 +74,7 @@ async fn main() -> anyhow::Result<()> {
     let mut mint_builder = MintBuilder::new();
 
     let settings = if config_file_arg.exists() {
-        config::Settings::new(Some(config_file_arg), true)
+        config::Settings::new(Some(config_file_arg))
     } else {
         tracing::info!("Config file does not exist. Attempting to read env vars");
         config::Settings::default()
@@ -82,7 +82,7 @@ async fn main() -> anyhow::Result<()> {
 
     // This check for any settings defined in ENV VARs
     // ENV VARS will take **priority** over those in the config
-    let settings = settings.from_env(true)?;
+    let settings = settings.from_env()?;
     let localstore = settings.database.engine.clone().mint(&work_dir).await?;
 
     mint_builder = mint_builder.with_localstore(localstore);

crates/cdk-signatory/Cargo.toml

@@ -6,7 +6,7 @@ description = "CDK signatory default implementation"
 
 [features]
 default = []
-server = []
+server = ["dep:tonic", "dep:prost"]
 
 [dependencies]
 async-trait = "0.1.83"
@@ -21,8 +21,8 @@ cdk-common = { path = "../cdk-common", default-features = false, features = [
 ] }
 tracing = "0.1.41"
 tokio = { version = "1.21", features = ["full"] }
-tonic = "0.12.3"
-prost = "0.13.4"
+tonic = { version = "0.12.3", optional = true }
+prost = { version = "0.13.4", optional = true }
 
 [build-dependencies]
 tonic-build = { version = "0.12.3", features = ["prost"] }

crates/cdk-signatory/src/lib.rs

@@ -25,8 +25,10 @@ use cdk_common::signatory::Signatory;
 use cdk_common::util::unix_time;
 use tokio::sync::RwLock;
 
+#[cfg(feature = "server")]
 pub mod proto;
 
+#[cfg(feature = "server")]
 pub use proto::client::RemoteSigner;
 
 /// Generate new [`MintKeySetInfo`] from path