aljaz/cdk
1
0
Fork 0
mirror of https://github.com/aljazceru/cdk.git synced 2025-12-18 21:25:09 +01:00
Code Issues Packages Projects Releases Wiki Activity

Mintd lib (#914)

Browse Source 
* 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 bfc594c11cf37caeaa6445cb854ae5567d2da6bd.

* 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
This commit is contained in:
thesimplekid
2025-07-31 00:43:43 -04:00
committed by GitHub
parent 9e4b768657
commit 3a3cd88ee9
33 changed files with 2468 additions and 1209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
crates/cdk-integration-tests/Cargo.toml
View File

@@ -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

163
crates/cdk-integration-tests/src/bin/start_fake_auth_mint.rs Normal file
View File

@@ -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(())
}

178
crates/cdk-integration-tests/src/bin/start_fake_mint.rs Normal file
View File

@@ -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(())
}

62
crates/cdk-integration-tests/src/bin/start_regtest.rs
View File

@@ -1,20 +1,33 @@
use std::fs::OpenOptions;
use std::io::Write;
use std::path::{Path, PathBuf};
use std::str::FromStr;
use std::sync::Arc;
use std::time::Duration;
use anyhow::{bail, Result};
use cdk_integration_tests::init_regtest::{get_temp_dir, start_regtest_end};
use anyhow::Result;
use cdk_integration_tests::cli::{init_logging, CommonArgs};
use cdk_integration_tests::init_regtest::start_regtest_end;
use clap::Parser;
use tokio::signal;
use tokio::sync::{oneshot, Notify};
use tokio::time::timeout;
use tracing_subscriber::EnvFilter;
fn signal_progress() {
let temp_dir = get_temp_dir();
#[derive(Parser)]
#[command(name = "start-regtest")]
#[command(about = "Start regtest environment", long_about = None)]
struct Args {
#[command(flatten)]
common: CommonArgs,
/// Working directory path
work_dir: String,
}
fn signal_progress(work_dir: &Path) {
let mut pipe = OpenOptions::new()
.write(true)
.open(temp_dir.join("progress_pipe"))
.open(work_dir.join("progress_pipe"))
.expect("Failed to open pipe");
pipe.write_all(b"checkpoint1\n")
@@ -23,24 +36,21 @@ fn signal_progress() {
#[tokio::main]
async fn main() -> Result<()> {
let default_filter = "debug";
let args = Args::parse();
let sqlx_filter = "sqlx=warn";
let hyper_filter = "hyper=warn";
let h2_filter = "h2=warn";
let rustls_filter = "rustls=warn";
// Initialize logging based on CLI arguments
init_logging(args.common.enable_logging, args.common.log_level);
let env_filter = EnvFilter::new(format!(
"{default_filter},{sqlx_filter},{hyper_filter},{h2_filter},{rustls_filter}"
));
tracing_subscriber::fmt().with_env_filter(env_filter).init();
let temp_dir = PathBuf::from_str(&args.work_dir)?;
let temp_dir_clone = temp_dir.clone();
let shutdown_regtest = Arc::new(Notify::new());
let shutdown_clone = shutdown_regtest.clone();
let shutdown_clone = Arc::clone(&shutdown_regtest);
let shutdown_clone_two = Arc::clone(&shutdown_regtest);
let (tx, rx) = oneshot::channel();
tokio::spawn(async move {
start_regtest_end(tx, shutdown_clone)
start_regtest_end(&temp_dir_clone, tx, shutdown_clone)
.await
.expect("Error starting regtest");
});
@@ -48,15 +58,25 @@ async fn main() -> Result<()> {
match timeout(Duration::from_secs(300), rx).await {
Ok(_) => {
tracing::info!("Regtest set up");
signal_progress();
signal_progress(&temp_dir);
}
Err(_) => {
tracing::error!("regtest setup timed out after 5 minutes");
bail!("Could not set up regtest");
anyhow::bail!("Could not set up regtest");
}
}
signal::ctrl_c().await?;
let shutdown_future = async {
// Wait for Ctrl+C signal
signal::ctrl_c()
.await
.expect("failed to install CTRL+C handler");
tracing::info!("Shutdown signal received");
println!("\nReceived Ctrl+C, shutting down mints...");
shutdown_clone_two.notify_waiters();
};
shutdown_future.await;
Ok(())
}

305
crates/cdk-integration-tests/src/bin/start_regtest_mints.rs Normal file
View File

@@ -0,0 +1,305 @@
//! Binary for starting regtest mints
//!
//! This binary provides a programmatic way to start regtest mints for testing purposes:
//! 1. Sets up a regtest environment with CLN and LND nodes
//! 2. Starts CLN and LND mint instances using the cdk-mintd library
//! 3. Configures the mints to connect to the respective Lightning Network backends
//! 4. Waits for both mints to be ready and responsive
//! 5. Keeps them running until interrupted (Ctrl+C)
//! 6. Gracefully shuts down all services 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::fs;
use std::path::Path;
use std::sync::Arc;
use std::time::Duration;
use anyhow::Result;
use cdk_integration_tests::cli::CommonArgs;
use cdk_integration_tests::init_regtest::start_regtest_end;
use cdk_integration_tests::shared;
use clap::Parser;
use tokio::signal::unix::SignalKind;
use tokio::signal::{self};
use tokio::sync::{oneshot, Notify};
use tokio::time::timeout;
#[derive(Parser)]
#[command(name = "start-regtest-mints")]
#[command(about = "Start regtest mints", long_about = None)]
struct Args {
#[command(flatten)]
common: CommonArgs,
/// Database type (sqlite)
database_type: String,
/// Working directory path
work_dir: String,
/// Mint address (default: 127.0.0.1)
#[arg(default_value = "127.0.0.1")]
mint_addr: String,
/// CLN port (default: 8085)
#[arg(default_value_t = 8085)]
cln_port: u16,
/// LND port (default: 8087)
#[arg(default_value_t = 8087)]
lnd_port: u16,
}
/// Start regtest CLN mint using the library
async fn start_cln_mint(
temp_dir: &Path,
port: u16,
shutdown: Arc<Notify>,
) -> Result<tokio::task::JoinHandle<()>> {
let cln_rpc_path = temp_dir
.join("cln")
.join("one")
.join("regtest")
.join("lightning-rpc");
let cln_config = cdk_mintd::config::Cln {
rpc_path: cln_rpc_path,
bolt12: false,
fee_percent: 0.0,
reserve_fee_min: 0.into(),
};
// Create settings struct for CLN mint using shared function
let settings = shared::create_cln_settings(
port,
temp_dir
.join("cln")
.join("one")
.join("regtest")
.join("lightning-rpc"),
"eye survey guilt napkin crystal cup whisper salt luggage manage unveil loyal".to_string(),
cln_config,
);
println!("Starting CLN 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!("CLN mint shutdown signal received");
};
match cdk_mintd::run_mintd_with_shutdown(&temp_dir, &settings, shutdown_future, None).await
{
Ok(_) => println!("CLN mint exited normally"),
Err(e) => eprintln!("CLN mint exited with error: {e}"),
}
});
Ok(handle)
}
/// Start regtest LND mint using the library
async fn start_lnd_mint(
temp_dir: &Path,
port: u16,
shutdown: Arc<Notify>,
) -> Result<tokio::task::JoinHandle<()>> {
let lnd_cert_file = temp_dir.join("lnd").join("two").join("tls.cert");
let lnd_macaroon_file = temp_dir
.join("lnd")
.join("two")
.join("data")
.join("chain")
.join("bitcoin")
.join("regtest")
.join("admin.macaroon");
let lnd_work_dir = temp_dir.join("lnd_mint");
// Create work directory for LND mint
fs::create_dir_all(&lnd_work_dir)?;
let lnd_config = cdk_mintd::config::Lnd {
address: "https://localhost:10010".to_string(),
cert_file: lnd_cert_file,
macaroon_file: lnd_macaroon_file,
fee_percent: 0.0,
reserve_fee_min: 0.into(),
};
// Create settings struct for LND mint using shared function
let settings = shared::create_lnd_settings(
port,
lnd_config,
"cattle gold bind busy sound reduce tone addict baby spend february strategy".to_string(),
);
println!("Starting LND mintd on port {port}");
let lnd_work_dir = lnd_work_dir.clone();
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!("LND mint shutdown signal received");
};
match cdk_mintd::run_mintd_with_shutdown(&lnd_work_dir, &settings, shutdown_future, None)
.await
{
Ok(_) => println!("LND mint exited normally"),
Err(e) => eprintln!("LND 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
let mint_url_1 = format!("http://{}:{}", args.mint_addr, args.cln_port);
let mint_url_2 = format!("http://{}:{}", args.mint_addr, args.lnd_port);
let env_vars: Vec<(&str, &str)> = vec![
("CDK_TEST_MINT_URL", &mint_url_1),
("CDK_TEST_MINT_URL_2", &mint_url_2),
];
shared::write_env_file(&temp_dir, &env_vars)?;
// Start regtest
println!("Starting regtest...");
let shutdown_regtest = shared::create_shutdown_handler();
let shutdown_clone = shutdown_regtest.clone();
let (tx, rx) = oneshot::channel();
let shutdown_clone_one = Arc::clone(&shutdown_clone);
let temp_dir_clone = temp_dir.clone();
tokio::spawn(async move {
start_regtest_end(&temp_dir_clone, tx, shutdown_clone_one)
.await
.expect("Error starting regtest");
});
match timeout(Duration::from_secs(300), rx).await {
Ok(_) => {
tracing::info!("Regtest set up");
}
Err(_) => {
tracing::error!("regtest setup timed out after 5 minutes");
anyhow::bail!("Could not set up regtest");
}
}
// Start CLN mint
let cln_handle = start_cln_mint(&temp_dir, args.cln_port, shutdown_clone.clone()).await?;
// Wait for CLN mint to be ready
if let Err(e) = shared::wait_for_mint_ready(args.cln_port, 100).await {
eprintln!("Error waiting for CLN mint: {e}");
return Err(e);
}
// Start LND mint
let lnd_handle = start_lnd_mint(&temp_dir, args.lnd_port, shutdown_clone.clone()).await?;
// Wait for LND mint to be ready
if let Err(e) = shared::wait_for_mint_ready(args.lnd_port, 100).await {
eprintln!("Error waiting for LND mint: {e}");
return Err(e);
}
println!("All regtest mints started successfully!");
println!("CLN mint: http://{}:{}", args.mint_addr, args.cln_port);
println!("LND mint: http://{}:{}", args.mint_addr, args.lnd_port);
shared::display_mint_info(args.cln_port, &temp_dir, &args.database_type); // Using CLN port for display
println!();
println!("Environment variables set:");
println!(
" CDK_TEST_MINT_URL=http://{}:{}",
args.mint_addr, args.cln_port
);
println!(
" CDK_TEST_MINT_URL_2=http://{}:{}",
args.mint_addr, args.lnd_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 regtest");
println!(" cargo test -p cdk-integration-tests --test happy_path_mint_wallet");
println!(" etc.");
println!();
println!("Press Ctrl+C to stop the mints...");
// Create a future to wait for either Ctrl+C signal or unexpected mint termination
let shutdown_future = async {
// Wait for either SIGINT (Ctrl+C) or SIGTERM
let mut sigterm = signal::unix::signal(SignalKind::terminate())
.expect("Failed to create SIGTERM signal handler");
tokio::select! {
_ = signal::ctrl_c() => {
tracing::info!("Received SIGINT (Ctrl+C), shutting down mints...");
}
_ = sigterm.recv() => {
tracing::info!("Received SIGTERM, shutting down mints...");
}
}
println!("\nShutdown signal received, shutting down mints...");
shutdown_clone.notify_waiters();
};
// Monitor mint handles for unexpected termination
let monitor_mints = async {
loop {
if cln_handle.is_finished() {
println!("CLN mint finished unexpectedly");
return;
}
if lnd_handle.is_finished() {
println!("LND mint finished unexpectedly");
return;
}
tokio::time::sleep(Duration::from_millis(100)).await;
}
};
// Wait for either shutdown signal or mint termination
tokio::select! {
_ = shutdown_future => {
println!("Shutdown signal received, waiting for mints to stop...");
}
_ = monitor_mints => {
println!("One or more mints terminated unexpectedly");
}
}
// Wait for mints to finish gracefully
if let Err(e) = tokio::try_join!(cln_handle, lnd_handle) {
eprintln!("Error waiting for mints to shut down: {e}");
}
println!("All services shut down successfully");
Ok(())
}

42
crates/cdk-integration-tests/src/cli.rs Normal file
View File

@@ -0,0 +1,42 @@
//! Common CLI and logging utilities for CDK integration test binaries
//!
//! This module provides standardized CLI argument parsing and logging setup
//! for integration test binaries.
use clap::Parser;
use tracing_subscriber::EnvFilter;
/// Common CLI arguments for CDK integration test binaries
#[derive(Parser, Debug)]
pub struct CommonArgs {
/// Enable logging (default is false)
#[arg(long, default_value_t = false)]
pub enable_logging: bool,
/// Logging level when enabled (default is debug)
#[arg(long, default_value = "debug")]
pub log_level: tracing::Level,
}
/// Initialize logging based on CLI arguments
pub fn init_logging(enable_logging: bool, log_level: tracing::Level) {
if enable_logging {
let default_filter = log_level.to_string();
// Common filters to reduce noise
let sqlx_filter = "sqlx=warn";
let hyper_filter = "hyper=warn";
let h2_filter = "h2=warn";
let rustls_filter = "rustls=warn";
let reqwest_filter = "reqwest=warn";
let env_filter = EnvFilter::new(format!(
"{default_filter},{sqlx_filter},{hyper_filter},{h2_filter},{rustls_filter},{reqwest_filter}"
));
// Ok if successful, Err if already initialized
let _ = tracing_subscriber::fmt()
.with_env_filter(env_filter)
.try_init();
}
}

4
crates/cdk-integration-tests/src/init_pure_tests.rs
View File

@@ -211,10 +211,10 @@ impl MintConnector for DirectMintConnection {
pub fn setup_tracing() {
let default_filter = "debug";
let sqlx_filter = "sqlx=warn";
let h2_filter = "h2=warn";
let hyper_filter = "hyper=warn";
let env_filter = EnvFilter::new(format!("{default_filter},{sqlx_filter},{hyper_filter}"));
let env_filter = EnvFilter::new(format!("{default_filter},{h2_filter},{hyper_filter}"));
// Ok if successful, Err if already initialized
// Allows us to setup tracing at the start of several parallel tests

98
crates/cdk-integration-tests/src/init_regtest.rs
View File

@@ -31,21 +31,41 @@ pub const LND_TWO_RPC_ADDR: &str = "localhost:10010";
pub const CLN_ADDR: &str = "127.0.0.1:19846";
pub const CLN_TWO_ADDR: &str = "127.0.0.1:19847";
pub fn get_mint_addr() -> String {
env::var("CDK_ITESTS_MINT_ADDR").expect("Mint address not set")
/// Configuration for regtest environment
pub struct RegtestConfig {
pub mint_addr: String,
pub cln_port: u16,
pub lnd_port: u16,
pub temp_dir: PathBuf,
}
pub fn get_mint_port(which: &str) -> u16 {
let dir = env::var(format!("CDK_ITESTS_MINT_PORT_{which}")).expect("Mint port not set");
dir.parse().unwrap()
impl Default for RegtestConfig {
fn default() -> Self {
Self {
mint_addr: "127.0.0.1".to_string(),
cln_port: 8085,
lnd_port: 8087,
temp_dir: std::env::temp_dir().join("cdk-itests-default"),
}
}
}
pub fn get_mint_url(which: &str) -> String {
format!("http://{}:{}", get_mint_addr(), get_mint_port(which))
pub fn get_mint_url_with_config(config: &RegtestConfig, which: &str) -> String {
let port = match which {
"0" => config.cln_port,
"1" => config.lnd_port,
_ => panic!("Unknown mint identifier: {which}"),
};
format!("http://{}:{}", config.mint_addr, port)
}
pub fn get_mint_ws_url(which: &str) -> String {
format!("ws://{}:{}/v1/ws", get_mint_addr(), get_mint_port(which))
pub fn get_mint_ws_url_with_config(config: &RegtestConfig, which: &str) -> String {
let port = match which {
"0" => config.cln_port,
"1" => config.lnd_port,
_ => panic!("Unknown mint identifier: {which}"),
};
format!("ws://{}:{}/v1/ws", config.mint_addr, port)
}
pub fn get_temp_dir() -> PathBuf {
@@ -54,15 +74,19 @@ pub fn get_temp_dir() -> PathBuf {
dir.parse().expect("Valid path buf")
}
pub fn get_bitcoin_dir() -> PathBuf {
let dir = get_temp_dir().join(BITCOIN_DIR);
pub fn get_temp_dir_with_config(config: &RegtestConfig) -> &PathBuf {
&config.temp_dir
}
pub fn get_bitcoin_dir(temp_dir: &Path) -> PathBuf {
let dir = temp_dir.join(BITCOIN_DIR);
std::fs::create_dir_all(&dir).unwrap();
dir
}
pub fn init_bitcoind() -> Bitcoind {
pub fn init_bitcoind(work_dir: &Path) -> Bitcoind {
Bitcoind::new(
get_bitcoin_dir(),
get_bitcoin_dir(work_dir),
BITCOIND_ADDR.parse().unwrap(),
BITCOIN_RPC_USER.to_string(),
BITCOIN_RPC_PASS.to_string(),
@@ -81,14 +105,14 @@ pub fn init_bitcoin_client() -> Result<BitcoinClient> {
)
}
pub fn get_cln_dir(name: &str) -> PathBuf {
let dir = get_temp_dir().join("cln").join(name);
pub fn get_cln_dir(work_dir: &Path, name: &str) -> PathBuf {
let dir = work_dir.join("cln").join(name);
std::fs::create_dir_all(&dir).unwrap();
dir
}
pub fn get_lnd_dir(name: &str) -> PathBuf {
let dir = get_temp_dir().join("lnd").join(name);
pub fn get_lnd_dir(work_dir: &Path, name: &str) -> PathBuf {
let dir = work_dir.join("lnd").join(name);
std::fs::create_dir_all(&dir).unwrap();
dir
}
@@ -101,9 +125,14 @@ pub fn get_lnd_macaroon_path(lnd_dir: &Path) -> PathBuf {
lnd_dir.join("data/chain/bitcoin/regtest/admin.macaroon")
}
pub async fn init_lnd(lnd_dir: PathBuf, lnd_addr: &str, lnd_rpc_addr: &str) -> Lnd {
pub async fn init_lnd(
work_dir: &Path,
lnd_dir: PathBuf,
lnd_addr: &str,
lnd_rpc_addr: &str,
) -> Lnd {
Lnd::new(
get_bitcoin_dir(),
get_bitcoin_dir(work_dir),
lnd_dir,
lnd_addr.parse().unwrap(),
lnd_rpc_addr.to_string(),
@@ -192,8 +221,12 @@ where
Ok(())
}
pub async fn start_regtest_end(sender: Sender<()>, notify: Arc<Notify>) -> anyhow::Result<()> {
let mut bitcoind = init_bitcoind();
pub async fn start_regtest_end(
work_dir: &Path,
sender: Sender<()>,
notify: Arc<Notify>,
) -> anyhow::Result<()> {
let mut bitcoind = init_bitcoind(work_dir);
bitcoind.start_bitcoind()?;
let bitcoin_client = init_bitcoin_client()?;
@@ -203,9 +236,9 @@ pub async fn start_regtest_end(sender: Sender<()>, notify: Arc<Notify>) -> anyho
let new_add = bitcoin_client.get_new_address()?;
bitcoin_client.generate_blocks(&new_add, 200).unwrap();
let cln_one_dir = get_cln_dir("one");
let cln_one_dir = get_cln_dir(work_dir, "one");
let mut clnd = Clnd::new(
get_bitcoin_dir(),
get_bitcoin_dir(work_dir),
cln_one_dir.clone(),
CLN_ADDR.into(),
BITCOIN_RPC_USER.to_string(),
@@ -220,9 +253,9 @@ pub async fn start_regtest_end(sender: Sender<()>, notify: Arc<Notify>) -> anyho
fund_ln(&bitcoin_client, &cln_client).await.unwrap();
// Create second cln
let cln_two_dir = get_cln_dir("two");
let cln_two_dir = get_cln_dir(work_dir, "two");
let mut clnd_two = Clnd::new(
get_bitcoin_dir(),
get_bitcoin_dir(work_dir),
cln_two_dir.clone(),
CLN_TWO_ADDR.into(),
BITCOIN_RPC_USER.to_string(),
@@ -236,10 +269,10 @@ pub async fn start_regtest_end(sender: Sender<()>, notify: Arc<Notify>) -> anyho
fund_ln(&bitcoin_client, &cln_two_client).await.unwrap();
let lnd_dir = get_lnd_dir("one");
let lnd_dir = get_lnd_dir(work_dir, "one");
println!("{}", lnd_dir.display());
let mut lnd = init_lnd(lnd_dir.clone(), LND_ADDR, LND_RPC_ADDR).await;
let mut lnd = init_lnd(work_dir, lnd_dir.clone(), LND_ADDR, LND_RPC_ADDR).await;
lnd.start_lnd().unwrap();
tracing::info!("Started lnd node");
@@ -255,8 +288,15 @@ pub async fn start_regtest_end(sender: Sender<()>, notify: Arc<Notify>) -> anyho
fund_ln(&bitcoin_client, &lnd_client).await.unwrap();
// create second lnd node
let lnd_two_dir = get_lnd_dir("two");
let mut lnd_two = init_lnd(lnd_two_dir.clone(), LND_TWO_ADDR, LND_TWO_RPC_ADDR).await;
let work_dir = get_temp_dir();
let lnd_two_dir = get_lnd_dir(&work_dir, "two");
let mut lnd_two = init_lnd(
&work_dir,
lnd_two_dir.clone(),
LND_TWO_ADDR,
LND_TWO_RPC_ADDR,
)
.await;
lnd_two.start_lnd().unwrap();
tracing::info!("Started second lnd node");

73
crates/cdk-integration-tests/src/lib.rs
View File

@@ -1,4 +1,23 @@
//! Integration Test Library
//!
//! This crate provides shared functionality for CDK integration tests.
//! It includes utilities for setting up test environments, funding wallets,
//! and common test operations across different test scenarios.
//!
//! Test Categories Supported:
//! - Pure in-memory tests (no external dependencies)
//! - Regtest environment tests (with actual Lightning nodes)
//! - Authenticated mint tests
//! - Multi-mint scenarios
//!
//! Key Components:
//! - Test environment initialization
//! - Wallet funding utilities
//! - Lightning Network client helpers
//! - Proof state management utilities
use std::env;
use std::path::Path;
use std::sync::Arc;
use anyhow::{anyhow, bail, Result};
@@ -8,13 +27,15 @@ use cdk::nuts::{MintQuoteState, NotificationPayload, State};
use cdk::wallet::WalletSubscription;
use cdk::Wallet;
use cdk_fake_wallet::create_fake_invoice;
use init_regtest::{get_lnd_dir, get_mint_url, LND_RPC_ADDR};
use init_regtest::{get_lnd_dir, LND_RPC_ADDR};
use ln_regtest_rs::ln_client::{LightningClient, LndClient};
use tokio::time::{sleep, timeout, Duration};
pub mod cli;
pub mod init_auth_mint;
pub mod init_pure_tests;
pub mod init_regtest;
pub mod shared;
pub async fn fund_wallet(wallet: Arc<Wallet>, amount: Amount) {
let quote = wallet
@@ -32,6 +53,20 @@ pub async fn fund_wallet(wallet: Arc<Wallet>, amount: Amount) {
.expect("Could not mint");
}
pub fn get_mint_url_from_env() -> String {
match env::var("CDK_TEST_MINT_URL") {
Ok(url) => url,
Err(_) => panic!("Mint url not set"),
}
}
pub fn get_second_mint_url_from_env() -> String {
match env::var("CDK_TEST_MINT_URL_2") {
Ok(url) => url,
Err(_) => panic!("Mint url not set"),
}
}
// Get all pending from wallet and attempt to swap
// Will panic if there are no pending
// Will return Ok if swap fails as expected
@@ -151,33 +186,9 @@ pub async fn wait_for_mint_to_be_paid(
}
}
/// Gets the mint URL from environment variable or falls back to default
///
/// Checks the CDK_TEST_MINT_URL environment variable:
/// - If set, returns that URL
/// - Otherwise falls back to the default URL from get_mint_url("0")
pub fn get_mint_url_from_env() -> String {
match env::var("CDK_TEST_MINT_URL") {
Ok(url) => url,
Err(_) => get_mint_url("0"),
}
}
/// Gets the second mint URL from environment variable or falls back to default
///
/// Checks the CDK_TEST_MINT_URL_2 environment variable:
/// - If set, returns that URL
/// - Otherwise falls back to the default URL from get_mint_url("1")
pub fn get_second_mint_url_from_env() -> String {
match env::var("CDK_TEST_MINT_URL_2") {
Ok(url) => url,
Err(_) => get_mint_url("1"),
}
}
// This is the ln wallet we use to send/receive ln payements as the wallet
pub async fn init_lnd_client() -> LndClient {
let lnd_dir = get_lnd_dir("one");
pub async fn init_lnd_client(work_dir: &Path) -> LndClient {
let lnd_dir = get_lnd_dir(work_dir, "one");
let cert_file = lnd_dir.join("tls.cert");
let macaroon_file = lnd_dir.join("data/chain/bitcoin/regtest/admin.macaroon");
LndClient::new(format!("https://{LND_RPC_ADDR}"), cert_file, macaroon_file)
@@ -189,10 +200,10 @@ pub async fn init_lnd_client() -> LndClient {
///
/// This is useful for tests that need to pay invoices in regtest mode but
/// should be skipped in other environments.
pub async fn pay_if_regtest(invoice: &Bolt11Invoice) -> Result<()> {
pub async fn pay_if_regtest(work_dir: &Path, invoice: &Bolt11Invoice) -> Result<()> {
// Check if the invoice is for the regtest network
if invoice.network() == bitcoin::Network::Regtest {
let lnd_client = init_lnd_client().await;
let lnd_client = init_lnd_client(work_dir).await;
lnd_client.pay_invoice(invoice.to_string()).await?;
Ok(())
} else {
@@ -220,10 +231,10 @@ pub fn is_regtest_env() -> bool {
///
/// Uses the is_regtest_env() function to determine whether to
/// create a real regtest invoice or a fake one for testing.
pub async fn create_invoice_for_env(amount_sat: Option<u64>) -> Result<String> {
pub async fn create_invoice_for_env(work_dir: &Path, amount_sat: Option<u64>) -> Result<String> {
if is_regtest_env() {
// In regtest mode, create a real invoice
let lnd_client = init_lnd_client().await;
let lnd_client = init_lnd_client(work_dir).await;
lnd_client
.create_invoice(amount_sat)
.await

266
crates/cdk-integration-tests/src/shared.rs Normal file
View File

@@ -0,0 +1,266 @@
//! Shared utilities for mint integration tests
//!
//! This module provides common functionality used across different
//! integration test binaries to reduce code duplication.
use std::fs;
use std::path::{Path, PathBuf};
use std::str::FromStr;
use std::sync::Arc;
use std::time::Duration;
use anyhow::Result;
use cdk_axum::cache;
use tokio::signal;
use tokio::sync::Notify;
use crate::cli::{init_logging, CommonArgs};
/// Default minimum mint amount for test mints
const DEFAULT_MIN_MINT: u64 = 1;
/// Default maximum mint amount for test mints
const DEFAULT_MAX_MINT: u64 = 500_000;
/// Default minimum melt amount for test mints
const DEFAULT_MIN_MELT: u64 = 1;
/// Default maximum melt amount for test mints
const DEFAULT_MAX_MELT: u64 = 500_000;
/// Wait for mint to be ready by checking its info endpoint
pub async fn wait_for_mint_ready(port: u16, timeout_secs: u64) -> Result<()> {
let url = format!("http://127.0.0.1:{port}/v1/info");
let start_time = std::time::Instant::now();
println!("Waiting for mint on port {port} to be ready...");
loop {
// Check if timeout has been reached
if start_time.elapsed().as_secs() > timeout_secs {
return Err(anyhow::anyhow!("Timeout waiting for mint on port {}", port));
}
// Try to make a request to the mint info endpoint
match reqwest::get(&url).await {
Ok(response) => {
if response.status().is_success() {
println!("Mint on port {port} is ready");
return Ok(());
} else {
println!(
"Mint on port {} returned status: {}",
port,
response.status()
);
}
}
Err(e) => {
println!("Error connecting to mint on port {port}: {e}");
}
}
tokio::time::sleep(Duration::from_secs(2)).await;
}
}
/// Initialize working directory
pub fn init_working_directory(work_dir: &str) -> Result<PathBuf> {
let temp_dir = PathBuf::from_str(work_dir)?;
// Create the temp directory if it doesn't exist
fs::create_dir_all(&temp_dir)?;
Ok(temp_dir)
}
/// Write environment variables to .env file
pub fn write_env_file(temp_dir: &Path, env_vars: &[(&str, &str)]) -> Result<()> {
let mut env_content = String::new();
for (key, value) in env_vars {
env_content.push_str(&format!("{key}={value}\n"));
}
let env_file_path = temp_dir.join(".env");
fs::write(&env_file_path, &env_content)
.map(|_| {
println!(
"Environment variables written to: {}",
env_file_path.display()
);
})
.map_err(|e| anyhow::anyhow!("Could not write .env file: {}", e))
}
/// Wait for .env file to be created
pub async fn wait_for_env_file(temp_dir: &Path, timeout_secs: u64) -> Result<()> {
let env_file_path = temp_dir.join(".env");
let start_time = std::time::Instant::now();
println!(
"Waiting for .env file to be created at: {}",
env_file_path.display()
);
loop {
// Check if timeout has been reached
if start_time.elapsed().as_secs() > timeout_secs {
return Err(anyhow::anyhow!(
"Timeout waiting for .env file at {}",
env_file_path.display()
));
}
// Check if the file exists
if env_file_path.exists() {
println!(".env file found at: {}", env_file_path.display());
return Ok(());
}
tokio::time::sleep(Duration::from_secs(1)).await;
}
}
/// Setup common logging based on CLI arguments
pub fn setup_logging(common_args: &CommonArgs) {
init_logging(common_args.enable_logging, common_args.log_level);
}
/// Create shutdown handler for graceful termination
pub fn create_shutdown_handler() -> Arc<Notify> {
Arc::new(Notify::new())
}
/// Wait for Ctrl+C signal
pub async fn wait_for_shutdown_signal(shutdown: Arc<Notify>) {
signal::ctrl_c()
.await
.expect("failed to install CTRL+C handler");
println!("\nReceived Ctrl+C, shutting down...");
shutdown.notify_waiters();
}
/// Common mint information display
pub fn display_mint_info(port: u16, temp_dir: &Path, database_type: &str) {
println!("Mint started successfully!");
println!("Mint URL: http://127.0.0.1:{port}");
println!("Temp directory: {temp_dir:?}");
println!("Database type: {database_type}");
}
/// Create settings for a fake wallet mint
pub fn create_fake_wallet_settings(
port: u16,
mnemonic: Option<String>,
signatory_config: Option<(String, String)>, // (url, certs_dir)
fake_wallet_config: Option<cdk_mintd::config::FakeWallet>,
) -> cdk_mintd::config::Settings {
cdk_mintd::config::Settings {
info: cdk_mintd::config::Info {
url: format!("http://127.0.0.1:{port}"),
listen_host: "127.0.0.1".to_string(),
listen_port: port,
mnemonic,
signatory_url: signatory_config.as_ref().map(|(url, _)| url.clone()),
signatory_certs: signatory_config
.as_ref()
.map(|(_, certs_dir)| certs_dir.clone()),
input_fee_ppk: None,
http_cache: cache::Config::default(),
enable_swagger_ui: None,
},
mint_info: cdk_mintd::config::MintInfo::default(),
ln: cdk_mintd::config::Ln {
ln_backend: cdk_mintd::config::LnBackend::FakeWallet,
invoice_description: None,
min_mint: DEFAULT_MIN_MINT.into(),
max_mint: DEFAULT_MAX_MINT.into(),
min_melt: DEFAULT_MIN_MELT.into(),
max_melt: DEFAULT_MAX_MELT.into(),
},
cln: None,
lnbits: None,
lnd: None,
fake_wallet: fake_wallet_config,
grpc_processor: None,
database: cdk_mintd::config::Database::default(),
mint_management_rpc: None,
auth: None,
}
}
/// Create settings for a CLN mint
pub fn create_cln_settings(
port: u16,
_cln_rpc_path: PathBuf,
mnemonic: String,
cln_config: cdk_mintd::config::Cln,
) -> cdk_mintd::config::Settings {
cdk_mintd::config::Settings {
info: cdk_mintd::config::Info {
url: format!("http://127.0.0.1:{port}"),
listen_host: "127.0.0.1".to_string(),
listen_port: port,
mnemonic: Some(mnemonic),
signatory_url: None,
signatory_certs: None,
input_fee_ppk: None,
http_cache: cache::Config::default(),
enable_swagger_ui: None,
},
mint_info: cdk_mintd::config::MintInfo::default(),
ln: cdk_mintd::config::Ln {
ln_backend: cdk_mintd::config::LnBackend::Cln,
invoice_description: None,
min_mint: DEFAULT_MIN_MINT.into(),
max_mint: DEFAULT_MAX_MINT.into(),
min_melt: DEFAULT_MIN_MELT.into(),
max_melt: DEFAULT_MAX_MELT.into(),
},
cln: Some(cln_config),
lnbits: None,
lnd: None,
fake_wallet: None,
grpc_processor: None,
database: cdk_mintd::config::Database::default(),
mint_management_rpc: None,
auth: None,
}
}
/// Create settings for an LND mint
pub fn create_lnd_settings(
port: u16,
lnd_config: cdk_mintd::config::Lnd,
mnemonic: String,
) -> cdk_mintd::config::Settings {
cdk_mintd::config::Settings {
info: cdk_mintd::config::Info {
url: format!("http://127.0.0.1:{port}"),
listen_host: "127.0.0.1".to_string(),
listen_port: port,
mnemonic: Some(mnemonic),
signatory_url: None,
signatory_certs: None,
input_fee_ppk: None,
http_cache: cache::Config::default(),
enable_swagger_ui: None,
},
mint_info: cdk_mintd::config::MintInfo::default(),
ln: cdk_mintd::config::Ln {
ln_backend: cdk_mintd::config::LnBackend::Lnd,
invoice_description: None,
min_mint: DEFAULT_MIN_MINT.into(),
max_mint: DEFAULT_MAX_MINT.into(),
min_melt: DEFAULT_MIN_MELT.into(),
max_melt: DEFAULT_MAX_MELT.into(),
},
cln: None,
lnbits: None,
lnd: Some(lnd_config),
fake_wallet: None,
grpc_processor: None,
database: cdk_mintd::config::Database::default(),
mint_management_rpc: None,
auth: None,
}
}

65
crates/cdk-integration-tests/tests/bolt12.rs
View File

@@ -1,3 +1,5 @@
use std::env;
use std::path::PathBuf;
use std::sync::Arc;
use anyhow::{bail, Result};
@@ -6,11 +8,45 @@ use cashu::amount::SplitTarget;
use cashu::nut23::Amountless;
use cashu::{Amount, CurrencyUnit, MintRequest, PreMintSecrets, ProofsMethods};
use cdk::wallet::{HttpClient, MintConnector, Wallet};
use cdk_integration_tests::init_regtest::get_cln_dir;
use cdk_integration_tests::init_regtest::{get_cln_dir, get_temp_dir};
use cdk_integration_tests::{get_mint_url_from_env, wait_for_mint_to_be_paid};
use cdk_sqlite::wallet::memory;
use ln_regtest_rs::ln_client::ClnClient;
// Helper function to get temp directory from environment or fallback
fn get_test_temp_dir() -> PathBuf {
match env::var("CDK_ITESTS_DIR") {
Ok(dir) => PathBuf::from(dir),
Err(_) => get_temp_dir(), // fallback to default
}
}
// Helper function to create CLN client with retries
async fn create_cln_client_with_retry(cln_dir: PathBuf) -> Result<ClnClient> {
let mut retries = 0;
let max_retries = 10;
loop {
match ClnClient::new(cln_dir.clone(), None).await {
Ok(client) => return Ok(client),
Err(e) => {
retries += 1;
if retries >= max_retries {
bail!(
"Could not connect to CLN client after {} retries: {}",
max_retries,
e
);
}
println!(
"Failed to connect to CLN (attempt {}/{}): {}. Retrying in 7 seconds...",
retries, max_retries, e
);
tokio::time::sleep(tokio::time::Duration::from_secs(7)).await;
}
}
}
}
/// Tests basic BOLT12 minting functionality:
/// - Creates a wallet
/// - Gets a BOLT12 quote for a specific amount (100 sats)
@@ -36,8 +72,11 @@ async fn test_regtest_bolt12_mint() {
assert_eq!(mint_quote.amount, Some(mint_amount));
let cln_one_dir = get_cln_dir("one");
let cln_client = ClnClient::new(cln_one_dir.clone(), None).await.unwrap();
let work_dir = get_test_temp_dir();
let cln_one_dir = get_cln_dir(&work_dir, "one");
let cln_client = create_cln_client_with_retry(cln_one_dir.clone())
.await
.unwrap();
cln_client
.pay_bolt12_offer(None, mint_quote.request)
.await
@@ -68,8 +107,9 @@ async fn test_regtest_bolt12_mint_multiple() -> Result<()> {
let mint_quote = wallet.mint_bolt12_quote(None, None).await?;
let cln_one_dir = get_cln_dir("one");
let cln_client = ClnClient::new(cln_one_dir.clone(), None).await?;
let work_dir = get_test_temp_dir();
let cln_one_dir = get_cln_dir(&work_dir, "one");
let cln_client = create_cln_client_with_retry(cln_one_dir.clone()).await?;
cln_client
.pay_bolt12_offer(Some(10000), mint_quote.request.clone())
.await
@@ -131,8 +171,9 @@ async fn test_regtest_bolt12_multiple_wallets() -> Result<()> {
)?;
// Create a BOLT12 offer that both wallets will use
let cln_one_dir = get_cln_dir("one");
let cln_client = ClnClient::new(cln_one_dir.clone(), None).await?;
let work_dir = get_test_temp_dir();
let cln_one_dir = get_cln_dir(&work_dir, "one");
let cln_client = create_cln_client_with_retry(cln_one_dir.clone()).await?;
// First wallet payment
let quote_one = wallet_one
.mint_bolt12_quote(Some(10_000.into()), None)
@@ -222,8 +263,9 @@ async fn test_regtest_bolt12_melt() -> Result<()> {
assert_eq!(mint_quote.amount, Some(mint_amount));
// Pay the quote
let cln_one_dir = get_cln_dir("one");
let cln_client = ClnClient::new(cln_one_dir.clone(), None).await?;
let work_dir = get_test_temp_dir();
let cln_one_dir = get_cln_dir(&work_dir, "one");
let cln_client = create_cln_client_with_retry(cln_one_dir.clone()).await?;
cln_client
.pay_bolt12_offer(None, mint_quote.request.clone())
.await?;
@@ -281,8 +323,9 @@ async fn test_regtest_bolt12_mint_extra() -> Result<()> {
let pay_amount_msats = 10_000;
let cln_one_dir = get_cln_dir("one");
let cln_client = ClnClient::new(cln_one_dir.clone(), None).await?;
let work_dir = get_test_temp_dir();
let cln_one_dir = get_cln_dir(&work_dir, "one");
let cln_client = create_cln_client_with_retry(cln_one_dir.clone()).await?;
cln_client
.pay_bolt12_offer(Some(pay_amount_msats), mint_quote.request.clone())
.await?;

50
crates/cdk-integration-tests/tests/fake_wallet.rs
View File

@@ -1,3 +1,19 @@
//! Fake Wallet Integration Tests
//!
//! This file contains tests for the fake wallet backend functionality.
//! The fake wallet simulates Lightning Network behavior for testing purposes,
//! allowing verification of mint behavior in various payment scenarios without
//! requiring a real Lightning node.
//!
//! Test Scenarios:
//! - Pending payment states and proof handling
//! - Payment failure cases and proof state management
//! - Change output verification in melt operations
//! - Witness signature validation
//! - Cross-unit transaction validation
//! - Overflow and balance validation
//! - Duplicate proof detection
use std::sync::Arc;
use bip39::Mnemonic;
@@ -408,40 +424,6 @@ async fn test_fake_melt_change_in_quote() {
assert_eq!(melt_change, check);
}
/// Tests that the correct database type is used based on environment variables
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test_database_type() {
// Get the database type and work dir from environment
let db_type = std::env::var("CDK_MINTD_DATABASE").expect("MINT_DATABASE env var should be set");
let work_dir =
std::env::var("CDK_MINTD_WORK_DIR").expect("CDK_MINTD_WORK_DIR env var should be set");
// Check that the correct database file exists
match db_type.as_str() {
"REDB" => {
let db_path = std::path::Path::new(&work_dir).join("cdk-mintd.redb");
assert!(
db_path.exists(),
"Expected redb database file to exist at {:?}",
db_path
);
}
"SQLITE" => {
let db_path = std::path::Path::new(&work_dir).join("cdk-mintd.sqlite");
assert!(
db_path.exists(),
"Expected sqlite database file to exist at {:?}",
db_path
);
}
"MEMORY" => {
// Memory database has no file to check
println!("Memory database in use - no file to check");
}
_ => panic!("Unknown database type: {}", db_type),
}
}
/// Tests minting tokens with a valid witness signature
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test_fake_mint_with_witness() {

37
crates/cdk-integration-tests/tests/happy_path_mint_wallet.rs
View File

@@ -11,6 +11,7 @@
use core::panic;
use std::env;
use std::fmt::Debug;
use std::path::PathBuf;
use std::str::FromStr;
use std::sync::Arc;
use std::time::Duration;
@@ -32,6 +33,14 @@ use tokio::time::timeout;
use tokio_tungstenite::connect_async;
use tokio_tungstenite::tungstenite::protocol::Message;
// Helper function to get temp directory from environment or fallback
fn get_test_temp_dir() -> PathBuf {
match env::var("CDK_ITESTS_DIR") {
Ok(dir) => PathBuf::from(dir),
Err(_) => panic!("Unknown test dir"),
}
}
async fn get_notification<T: StreamExt<Item = Result<Message, E>> + Unpin, E: Debug>(
reader: &mut T,
timeout_to_wait: Duration,
@@ -98,7 +107,9 @@ async fn test_happy_mint_melt_round_trip() {
let mint_quote = wallet.mint_quote(100.into(), None).await.unwrap();
let invoice = Bolt11Invoice::from_str(&mint_quote.request).unwrap();
pay_if_regtest(&invoice).await.unwrap();
pay_if_regtest(&get_test_temp_dir(), &invoice)
.await
.unwrap();
wait_for_mint_to_be_paid(&wallet, &mint_quote.id, 10)
.await
@@ -113,7 +124,9 @@ async fn test_happy_mint_melt_round_trip() {
assert!(mint_amount == 100.into());
let invoice = create_invoice_for_env(Some(50)).await.unwrap();
let invoice = create_invoice_for_env(&get_test_temp_dir(), Some(50))
.await
.unwrap();
let melt = wallet.melt_quote(invoice, None).await.unwrap();
@@ -217,7 +230,9 @@ async fn test_happy_mint() {
assert_eq!(mint_quote.amount, Some(mint_amount));
let invoice = Bolt11Invoice::from_str(&mint_quote.request).unwrap();
pay_if_regtest(&invoice).await.unwrap();
pay_if_regtest(&get_test_temp_dir(), &invoice)
.await
.unwrap();
wait_for_mint_to_be_paid(&wallet, &mint_quote.id, 60)
.await
@@ -262,7 +277,9 @@ async fn test_restore() {
let mint_quote = wallet.mint_quote(100.into(), None).await.unwrap();
let invoice = Bolt11Invoice::from_str(&mint_quote.request).unwrap();
pay_if_regtest(&invoice).await.unwrap();
pay_if_regtest(&get_test_temp_dir(), &invoice)
.await
.unwrap();
wait_for_mint_to_be_paid(&wallet, &mint_quote.id, 60)
.await
@@ -341,7 +358,7 @@ async fn test_fake_melt_change_in_quote() {
let bolt11 = Bolt11Invoice::from_str(&mint_quote.request).unwrap();
pay_if_regtest(&bolt11).await.unwrap();
pay_if_regtest(&get_test_temp_dir(), &bolt11).await.unwrap();
wait_for_mint_to_be_paid(&wallet, &mint_quote.id, 60)
.await
@@ -352,7 +369,9 @@ async fn test_fake_melt_change_in_quote() {
.await
.unwrap();
let invoice = create_invoice_for_env(Some(9)).await.unwrap();
let invoice = create_invoice_for_env(&get_test_temp_dir(), Some(9))
.await
.unwrap();
let proofs = wallet.get_unspent_proofs().await.unwrap();
@@ -408,7 +427,7 @@ async fn test_pay_invoice_twice() {
let mint_quote = wallet.mint_quote(100.into(), None).await.unwrap();
pay_if_regtest(&mint_quote.request.parse().unwrap())
pay_if_regtest(&get_test_temp_dir(), &mint_quote.request.parse().unwrap())
.await
.unwrap();
@@ -425,7 +444,9 @@ async fn test_pay_invoice_twice() {
assert_eq!(mint_amount, 100.into());
let invoice = create_invoice_for_env(Some(25)).await.unwrap();
let invoice = create_invoice_for_env(&get_test_temp_dir(), Some(25))
.await
.unwrap();
let melt_quote = wallet.melt_quote(invoice.clone(), None).await.unwrap();

5
crates/cdk-integration-tests/tests/integration_tests_pure.rs
View File

@@ -3,6 +3,11 @@
//! These tests verify the interaction between mint and wallet components, simulating real-world usage scenarios.
//! They test the complete flow of operations including wallet funding, token swapping, sending tokens between wallets,
//! and other operations that require client-mint interaction.
//!
//! Test Environment:
//! - Uses pure in-memory mint instances for fast execution
//! - Tests run concurrently with multi-threaded tokio runtime
//! - No external dependencies (Lightning nodes, databases) required
use std::assert_eq;
use std::collections::{HashMap, HashSet};

9
crates/cdk-integration-tests/tests/mint.rs
View File

@@ -1,8 +1,15 @@
//! Mint tests
//! Mint Tests
//!
//! This file contains tests that focus on the mint's internal functionality without client interaction.
//! These tests verify the mint's behavior in isolation, such as keyset management, database operations,
//! and other mint-specific functionality that doesn't require wallet clients.
//!
//! Test Categories:
//! - Keyset rotation and management
//! - Database transaction handling
//! - Internal state transitions
//! - Fee calculation and enforcement
//! - Proof validation and state management
use std::collections::{HashMap, HashSet};
use std::sync::Arc;

120
crates/cdk-integration-tests/tests/regtest.rs
View File

@@ -1,4 +1,20 @@
use std::str::FromStr;
//! Regtest Integration Tests
//!
//! This file contains tests that run against actual Lightning Network nodes in regtest mode.
//! These tests require a local development environment with LND nodes configured for regtest.
//!
//! Test Environment Setup:
//! - Uses actual LND nodes connected to a regtest Bitcoin network
//! - Tests real Lightning payment flows including invoice creation and payment
//! - Verifies mint behavior with actual Lightning Network interactions
//!
//! Running Tests:
//! - Requires CDK_TEST_REGTEST=1 environment variable to be set
//! - Requires properly configured LND nodes with TLS certificates and macaroons
//! - Uses real Bitcoin transactions in regtest mode
use std::env;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;
@@ -10,32 +26,46 @@ use cdk::nuts::{
NotificationPayload, PreMintSecrets,
};
use cdk::wallet::{HttpClient, MintConnector, Wallet, WalletSubscription};
use cdk_integration_tests::init_regtest::{
get_cln_dir, get_lnd_cert_file_path, get_lnd_dir, get_lnd_macaroon_path, get_mint_port,
LND_RPC_ADDR, LND_TWO_RPC_ADDR,
};
use cdk_integration_tests::init_regtest::{get_lnd_dir, LND_RPC_ADDR};
use cdk_integration_tests::{
get_mint_url_from_env, get_second_mint_url_from_env, wait_for_mint_to_be_paid,
};
use cdk_sqlite::wallet::{self, memory};
use futures::join;
use lightning_invoice::Bolt11Invoice;
use ln_regtest_rs::ln_client::{ClnClient, LightningClient, LndClient};
use ln_regtest_rs::InvoiceStatus;
use ln_regtest_rs::ln_client::{LightningClient, LndClient};
use tokio::time::timeout;
// This is the ln wallet we use to send/receive ln payements as the wallet
async fn init_lnd_client() -> LndClient {
let lnd_dir = get_lnd_dir("one");
// Try to get the temp directory from environment variable first (from .env file)
let temp_dir = match env::var("CDK_ITESTS_DIR") {
Ok(dir) => {
let path = PathBuf::from(dir);
println!("Using temp directory from CDK_ITESTS_DIR: {:?}", path);
path
}
Err(_) => {
panic!("Unknown temp dir");
}
};
// The LND mint uses the second LND node (LND_TWO_RPC_ADDR = localhost:10010)
let lnd_dir = get_lnd_dir(&temp_dir, "one");
let cert_file = lnd_dir.join("tls.cert");
let macaroon_file = lnd_dir.join("data/chain/bitcoin/regtest/admin.macaroon");
println!("Looking for LND cert file: {:?}", cert_file);
println!("Looking for LND macaroon file: {:?}", macaroon_file);
println!("Connecting to LND at: https://{}", LND_RPC_ADDR);
// Connect to LND
LndClient::new(
format!("https://{}", LND_RPC_ADDR),
cert_file,
macaroon_file,
cert_file.clone(),
macaroon_file.clone(),
)
.await
.unwrap()
.expect("Could not connect to lnd rpc")
}
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
@@ -98,41 +128,41 @@ async fn test_internal_payment() {
.await
.unwrap();
let check_paid = match get_mint_port("0") {
8085 => {
let cln_one_dir = get_cln_dir("one");
let cln_client = ClnClient::new(cln_one_dir.clone(), None).await.unwrap();
// let check_paid = match get_mint_port("0") {
// 8085 => {
// let cln_one_dir = get_cln_dir(&get_temp_dir(), "one");
// let cln_client = ClnClient::new(cln_one_dir.clone(), None).await.unwrap();
let payment_hash = Bolt11Invoice::from_str(&mint_quote.request).unwrap();
cln_client
.check_incoming_payment_status(&payment_hash.payment_hash().to_string())
.await
.expect("Could not check invoice")
}
8087 => {
let lnd_two_dir = get_lnd_dir("two");
let lnd_client = LndClient::new(
format!("https://{}", LND_TWO_RPC_ADDR),
get_lnd_cert_file_path(&lnd_two_dir),
get_lnd_macaroon_path(&lnd_two_dir),
)
.await
.unwrap();
let payment_hash = Bolt11Invoice::from_str(&mint_quote.request).unwrap();
lnd_client
.check_incoming_payment_status(&payment_hash.payment_hash().to_string())
.await
.expect("Could not check invoice")
}
_ => panic!("Unknown mint port"),
};
// let payment_hash = Bolt11Invoice::from_str(&mint_quote.request).unwrap();
// cln_client
// .check_incoming_payment_status(&payment_hash.payment_hash().to_string())
// .await
// .expect("Could not check invoice")
// }
// 8087 => {
// let lnd_two_dir = get_lnd_dir(&get_temp_dir(), "two");
// let lnd_client = LndClient::new(
// format!("https://{}", LND_TWO_RPC_ADDR),
// get_lnd_cert_file_path(&lnd_two_dir),
// get_lnd_macaroon_path(&lnd_two_dir),
// )
// .await
// .unwrap();
// let payment_hash = Bolt11Invoice::from_str(&mint_quote.request).unwrap();
// lnd_client
// .check_incoming_payment_status(&payment_hash.payment_hash().to_string())
// .await
// .expect("Could not check invoice")
// }
// _ => panic!("Unknown mint port"),
// };
match check_paid {
InvoiceStatus::Unpaid => (),
_ => {
panic!("Invoice has incorrect status: {:?}", check_paid);
}
}
// match check_paid {
// InvoiceStatus::Unpaid => (),
// _ => {
// panic!("Invoice has incorrect status: {:?}", check_paid);
// }
// }
let wallet_2_balance = wallet_2.total_balance().await.unwrap();

9
crates/cdk-integration-tests/tests/test_fees.rs
View File

@@ -6,6 +6,7 @@ use cashu::{Bolt11Invoice, ProofsMethods};
use cdk::amount::{Amount, SplitTarget};
use cdk::nuts::CurrencyUnit;
use cdk::wallet::{ReceiveOptions, SendKind, SendOptions, Wallet};
use cdk_integration_tests::init_regtest::get_temp_dir;
use cdk_integration_tests::{
create_invoice_for_env, get_mint_url_from_env, pay_if_regtest, wait_for_mint_to_be_paid,
};
@@ -26,7 +27,7 @@ async fn test_swap() {
let mint_quote = wallet.mint_quote(100.into(), None).await.unwrap();
let invoice = Bolt11Invoice::from_str(&mint_quote.request).unwrap();
pay_if_regtest(&invoice).await.unwrap();
pay_if_regtest(&get_temp_dir(), &invoice).await.unwrap();
wait_for_mint_to_be_paid(&wallet, &mint_quote.id, 10)
.await
@@ -93,7 +94,7 @@ async fn test_fake_melt_change_in_quote() {
let bolt11 = Bolt11Invoice::from_str(&mint_quote.request).unwrap();
pay_if_regtest(&bolt11).await.unwrap();
pay_if_regtest(&get_temp_dir(), &bolt11).await.unwrap();
wait_for_mint_to_be_paid(&wallet, &mint_quote.id, 60)
.await
@@ -106,7 +107,9 @@ async fn test_fake_melt_change_in_quote() {
let invoice_amount = 9;
let invoice = create_invoice_for_env(Some(invoice_amount)).await.unwrap();
let invoice = create_invoice_for_env(&get_temp_dir(), Some(invoice_amount))
.await
.unwrap();
let melt_quote = wallet.melt_quote(invoice.to_string(), None).await.unwrap();