Mintd lib (#914)

* feat(cdk-integration-tests): refactor regtest setup and mintd integration

- Replace shell-based regtest setup with Rust binary (start_regtest_mints)
- Add cdk-mintd crate to workspace and integration tests
- Improve environment variable handling for test configurations
- Update integration tests to use proper temp directory management
- Remove deprecated start_regtest.rs binary
- Enhance CLN client connection with retry logic
- Simplify regtest shell script (itests.sh) to use new binary
- Fix tracing filters and improve error handling in setup
- Update dependencies and configurations for integration tests

fix: killing

chore: comment tests for ci debugging

chore: compile

Revert "chore: comment tests for ci debugging"

This reverts commit bfc594c.

* chore: sql cipher

* fix: removal of sqlite cipher

* fix: auth password

* refactor(cdk-mintd): improve database password handling and function signatures

- Pass database password as parameter instead of parsing CLI args in setup_database
- Update function signatures for run_mintd and run_mintd_with_shutdown to accept db_password
- Remove direct CLI parsing from database setup logic
- Fix auth database initialization to use correct type when sqlcipher feature enabled

Author: thesimplekid

CHANGELOG.md

@@ -14,6 +14,10 @@
 - cashu: NUT-19 support in the wallet ([crodas]).
 - cdk: SIG_ALL support for swap and melt operations ([thesimplekid]).
 - cdk-sql-common: Add cache to SQL statements for better performance ([crodas]).
+- cdk-integration-tests: New binary `start_fake_auth_mint` for testing fake mint with authentication ([thesimplekid]).
+- cdk-integration-tests: New binary `start_fake_mint` for testing fake mint instances ([thesimplekid]).
+- cdk-integration-tests: New binary `start_regtest_mints` for testing regtest mints ([thesimplekid]).
+- cdk-integration-tests: Shared utilities module for common integration test functionality ([thesimplekid]).
 
 ### Changed
 - cdk: Refactored wallet keyset management methods for better clarity and separation of concerns ([thesimplekid]).
@@ -28,6 +32,12 @@
 - cdk-integration-tests: Updated test utilities to use new mint lifecycle management ([thesimplekid]).
 - cdk-sqlite: Introduce `cdk-sql-common` crate for shared SQL storage codebase ([crodas]).
 - cdk-sqlite: Rename `still_active` to `stale` for better clarity ([crodas]).
+- cdk-integration-tests: Refactored regtest setup to use Rust binaries instead of shell scripts ([thesimplekid]).
+- cdk-integration-tests: Improved environment variable handling for test configurations ([thesimplekid]).
+- cdk-integration-tests: Enhanced CLN client connection with retry logic ([thesimplekid]).
+- cdk-integration-tests: Updated integration tests to use proper temp directory management ([thesimplekid]).
+- cdk-integration-tests: Simplified regtest shell scripts to use new binaries ([thesimplekid]).
+- crates/cdk-mintd: Moved mintd library functions to separate module for better organization and testability ([thesimplekid]).
 
 ### Fixed
 - cashu: Fixed CurrencyUnit custom units preserving original case instead of being converted to uppercase ([thesimplekid]).

Cargo.toml

@@ -57,6 +57,7 @@ cdk-redb = { path = "./crates/cdk-redb", default-features = true, version = "=0.
 cdk-sql-common = { path = "./crates/cdk-sql-common", default-features = true, version = "=0.11.0" }
 cdk-sqlite = { path = "./crates/cdk-sqlite", default-features = true, version = "=0.11.0" }
 cdk-signatory = { path = "./crates/cdk-signatory", version = "=0.11.0", default-features = false }
+cdk-mintd = { path = "./crates/cdk-mintd", version = "=0.11.0", default-features = false }
 clap = { version = "4.5.31", features = ["derive"] }
 ciborium = { version = "0.2.2", default-features = false, features = ["std"] }
 cbor-diag = "0.1.12"

crates/cdk-integration-tests/Cargo.toml

@@ -23,10 +23,12 @@ cashu = { workspace = true, features = ["mint", "wallet"] }
 cdk = { workspace = true, features = ["mint", "wallet", "auth"] }
 cdk-cln = { workspace = true }
 cdk-lnd = { workspace = true }
-cdk-axum = { workspace = true }
+cdk-axum = { workspace = true, features = ["auth"] }
 cdk-sqlite = { workspace = true }
 cdk-redb = { workspace = true }
 cdk-fake-wallet = { workspace = true }
+cdk-common = { workspace = true, features = ["mint", "wallet", "auth"] }
+cdk-mintd = { workspace = true, features = ["cln", "lnd", "fakewallet", "grpc-processor", "auth", "lnbits", "management-rpc"] }
 futures = { workspace = true, default-features = false, features = [
     "executor",
 ] }
@@ -44,6 +46,7 @@ tower-http = { workspace = true, features = ["cors"] }
 tower-service = "0.3.3"
 reqwest.workspace = true
 bitcoin = "0.32.0"
+clap = { workspace = true, features = ["derive"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 tokio.workspace = true

crates/cdk-integration-tests/src/bin/start_fake_auth_mint.rs

@@ -0,0 +1,163 @@
+//! Binary for starting a fake mint with authentication for testing
+//!
+//! This binary provides a programmatic way to start a fake mint instance with authentication for testing purposes:
+//! 1. Sets up a fake mint instance with authentication using the cdk-mintd library
+//! 2. Configures OpenID Connect authentication settings
+//! 3. Waits for the mint to be ready and responsive
+//! 4. Keeps it running until interrupted (Ctrl+C)
+//! 5. Gracefully shuts down on receiving shutdown signal
+//!
+//! This approach offers better control and integration compared to external scripts,
+//! making it easier to run authentication integration tests with consistent configuration.
+
+use std::path::Path;
+use std::sync::Arc;
+
+use anyhow::Result;
+use bip39::Mnemonic;
+use cdk_integration_tests::cli::CommonArgs;
+use cdk_integration_tests::shared;
+use clap::Parser;
+use tokio::sync::Notify;
+
+#[derive(Parser)]
+#[command(name = "start-fake-auth-mint")]
+#[command(about = "Start a fake mint with authentication for testing", long_about = None)]
+struct Args {
+    #[command(flatten)]
+    common: CommonArgs,
+
+    /// Database type (sqlite)
+    database_type: String,
+
+    /// Working directory path
+    work_dir: String,
+
+    /// OpenID discovery URL
+    openid_discovery: String,
+
+    /// Port to listen on (default: 8087)
+    #[arg(default_value_t = 8087)]
+    port: u16,
+}
+
+/// Start a fake mint with authentication using the library
+async fn start_fake_auth_mint(
+    temp_dir: &Path,
+    port: u16,
+    openid_discovery: String,
+    shutdown: Arc<Notify>,
+) -> Result<tokio::task::JoinHandle<()>> {
+    println!("Starting fake auth mintd on port {port}");
+
+    // Create settings struct for fake mint with auth using shared function
+    let fake_wallet_config = cdk_mintd::config::FakeWallet {
+        supported_units: vec![cdk::nuts::CurrencyUnit::Sat, cdk::nuts::CurrencyUnit::Usd],
+        fee_percent: 0.0,
+        reserve_fee_min: cdk::Amount::from(1),
+        min_delay_time: 1,
+        max_delay_time: 3,
+    };
+
+    let mut settings = shared::create_fake_wallet_settings(
+        port,
+        Some(Mnemonic::generate(12)?.to_string()),
+        None,
+        Some(fake_wallet_config),
+    );
+
+    // Enable authentication
+    settings.auth = Some(cdk_mintd::config::Auth {
+        openid_discovery,
+        openid_client_id: "cashu-client".to_string(),
+        mint_max_bat: 50,
+        enabled_mint: true,
+        enabled_melt: true,
+        enabled_swap: true,
+        enabled_check_mint_quote: true,
+        enabled_check_melt_quote: true,
+        enabled_restore: true,
+        enabled_check_proof_state: true,
+    });
+
+    // Set description for the mint
+    settings.mint_info.description = "fake test mint with auth".to_string();
+
+    let temp_dir = temp_dir.to_path_buf();
+    let shutdown_clone = shutdown.clone();
+
+    // Run the mint in a separate task
+    let handle = tokio::spawn(async move {
+        // Create a future that resolves when the shutdown signal is received
+        let shutdown_future = async move {
+            shutdown_clone.notified().await;
+            println!("Fake auth mint shutdown signal received");
+        };
+
+        match cdk_mintd::run_mintd_with_shutdown(&temp_dir, &settings, shutdown_future, None).await
+        {
+            Ok(_) => println!("Fake auth mint exited normally"),
+            Err(e) => eprintln!("Fake auth mint exited with error: {e}"),
+        }
+    });
+
+    Ok(handle)
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let args = Args::parse();
+
+    // Initialize logging based on CLI arguments
+    shared::setup_logging(&args.common);
+
+    let temp_dir = shared::init_working_directory(&args.work_dir)?;
+
+    // Start fake auth mint
+    let shutdown = shared::create_shutdown_handler();
+    let shutdown_clone = shutdown.clone();
+
+    let handle = start_fake_auth_mint(
+        &temp_dir,
+        args.port,
+        args.openid_discovery.clone(),
+        shutdown_clone,
+    )
+    .await?;
+
+    // Wait for fake auth mint to be ready
+    if let Err(e) = shared::wait_for_mint_ready(args.port, 100).await {
+        eprintln!("Error waiting for fake auth mint: {e}");
+        return Err(e);
+    }
+
+    println!("Fake auth mint started successfully!");
+    println!("Fake auth mint: http://127.0.0.1:{}", args.port);
+    println!("Temp directory: {temp_dir:?}");
+    println!("Database type: {}", args.database_type);
+    println!("OpenID Discovery: {}", args.openid_discovery);
+    println!();
+    println!("Environment variables needed for tests:");
+    println!("  CDK_TEST_OIDC_USER=<username>");
+    println!("  CDK_TEST_OIDC_PASSWORD=<password>");
+    println!();
+    println!("You can now run auth integration tests with:");
+    println!("  cargo test -p cdk-integration-tests --test fake_auth");
+    println!();
+
+    println!("Press Ctrl+C to stop the mint...");
+
+    // Wait for Ctrl+C signal
+    shared::wait_for_shutdown_signal(shutdown).await;
+
+    println!("\nReceived Ctrl+C, shutting down mint...");
+
+    // Wait for mint to finish gracefully
+    if let Err(e) = handle.await {
+        eprintln!("Error waiting for mint to shut down: {e}");
+    }
+
+    println!("Mint shut down successfully");
+
+    Ok(())
+}

crates/cdk-integration-tests/src/bin/start_fake_mint.rs

@@ -0,0 +1,178 @@
+//! Binary for starting a fake mint for testing
+//!
+//! This binary provides a programmatic way to start a fake mint instance for testing purposes:
+//! 1. Sets up a fake mint instance using the cdk-mintd library
+//! 2. Configures the mint with fake wallet backend for testing Lightning Network interactions
+//! 3. Waits for the mint to be ready and responsive
+//! 4. Keeps it running until interrupted (Ctrl+C)
+//! 5. Gracefully shuts down on receiving shutdown signal
+//!
+//! This approach offers better control and integration compared to external scripts,
+//! making it easier to run integration tests with consistent configuration.
+
+use std::path::Path;
+use std::sync::Arc;
+
+use anyhow::Result;
+use cdk::nuts::CurrencyUnit;
+use cdk_integration_tests::cli::CommonArgs;
+use cdk_integration_tests::shared;
+use clap::Parser;
+use tokio::sync::Notify;
+
+#[derive(Parser)]
+#[command(name = "start-fake-mint")]
+#[command(about = "Start a fake mint for testing", long_about = None)]
+struct Args {
+    #[command(flatten)]
+    common: CommonArgs,
+
+    /// Database type (sqlite)
+    database_type: String,
+
+    /// Working directory path
+    work_dir: String,
+
+    /// Port to listen on (default: 8086)
+    #[arg(default_value_t = 8086)]
+    port: u16,
+
+    /// Use external signatory
+    #[arg(long, default_value_t = false)]
+    external_signatory: bool,
+}
+
+/// Start a fake mint using the library
+async fn start_fake_mint(
+    temp_dir: &Path,
+    port: u16,
+    shutdown: Arc<Notify>,
+    external_signatory: bool,
+) -> Result<tokio::task::JoinHandle<()>> {
+    let signatory_config = if external_signatory {
+        println!("Configuring external signatory");
+        Some((
+            "https://127.0.0.1:15060".to_string(),  // Default signatory URL
+            temp_dir.to_string_lossy().to_string(), // Certs directory as string
+        ))
+    } else {
+        None
+    };
+
+    let mnemonic = if external_signatory {
+        None
+    } else {
+        Some(
+            "eye survey guilt napkin crystal cup whisper salt luggage manage unveil loyal"
+                .to_string(),
+        )
+    };
+
+    let fake_wallet_config = Some(cdk_mintd::config::FakeWallet {
+        supported_units: vec![CurrencyUnit::Sat, CurrencyUnit::Usd],
+        fee_percent: 0.0,
+        reserve_fee_min: 1.into(),
+        min_delay_time: 1,
+        max_delay_time: 3,
+    });
+
+    // Create settings struct for fake mint using shared function
+    let settings =
+        shared::create_fake_wallet_settings(port, mnemonic, signatory_config, fake_wallet_config);
+
+    println!("Starting fake mintd on port {port}");
+
+    let temp_dir = temp_dir.to_path_buf();
+    let shutdown_clone = shutdown.clone();
+
+    // Run the mint in a separate task
+    let handle = tokio::spawn(async move {
+        // Create a future that resolves when the shutdown signal is received
+        let shutdown_future = async move {
+            shutdown_clone.notified().await;
+            println!("Fake mint shutdown signal received");
+        };
+
+        match cdk_mintd::run_mintd_with_shutdown(&temp_dir, &settings, shutdown_future, None).await
+        {
+            Ok(_) => println!("Fake mint exited normally"),
+            Err(e) => eprintln!("Fake mint exited with error: {e}"),
+        }
+    });
+
+    Ok(handle)
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let args = Args::parse();
+
+    // Initialize logging based on CLI arguments
+    shared::setup_logging(&args.common);
+
+    let temp_dir = shared::init_working_directory(&args.work_dir)?;
+
+    // Write environment variables to a .env file in the temp_dir BEFORE starting the mint
+    let mint_url = format!("http://127.0.0.1:{}", args.port);
+    let itests_dir = temp_dir.display().to_string();
+    let env_vars: Vec<(&str, &str)> = vec![
+        ("CDK_TEST_MINT_URL", &mint_url),
+        ("CDK_ITESTS_DIR", &itests_dir),
+    ];
+
+    shared::write_env_file(&temp_dir, &env_vars)?;
+
+    // Start fake mint
+    let shutdown = shared::create_shutdown_handler();
+    let shutdown_clone = shutdown.clone();
+
+    let handle = start_fake_mint(
+        &temp_dir,
+        args.port,
+        shutdown_clone,
+        args.external_signatory,
+    )
+    .await?;
+
+    // Wait for fake mint to be ready
+    if let Err(e) = shared::wait_for_mint_ready(args.port, 100).await {
+        eprintln!("Error waiting for fake mint: {e}");
+        return Err(e);
+    }
+
+    shared::display_mint_info(args.port, &temp_dir, &args.database_type);
+
+    println!();
+    println!(
+        "Environment variables written to: {}/.env",
+        temp_dir.display()
+    );
+    println!("You can source these variables with:");
+    println!("  source {}/.env", temp_dir.display());
+    println!();
+    println!("Environment variables set:");
+    println!("  CDK_TEST_MINT_URL=http://127.0.0.1:{}", args.port);
+    println!("  CDK_ITESTS_DIR={}", temp_dir.display());
+    println!();
+    println!("You can now run integration tests with:");
+    println!("  cargo test -p cdk-integration-tests --test fake_wallet");
+    println!("  cargo test -p cdk-integration-tests --test happy_path_mint_wallet");
+    println!("  etc.");
+    println!();
+
+    println!("Press Ctrl+C to stop the mint...");
+
+    // Wait for Ctrl+C signal
+    shared::wait_for_shutdown_signal(shutdown).await;
+
+    println!("\nReceived Ctrl+C, shutting down mint...");
+
+    // Wait for mint to finish gracefully
+    if let Err(e) = handle.await {
+        eprintln!("Error waiting for mint to shut down: {e}");
+    }
+
+    println!("Mint shut down successfully");
+
+    Ok(())
+}