aljaz/cdk
1
0
Fork 0
mirror of https://github.com/aljazceru/cdk.git synced 2026-02-23 14:06:56 +01:00
Code Issues Packages Projects Releases Wiki Activity

chore: Update rust-version (MSRV) to 1.75.0 (#623)

Browse Source
This commit is contained in:
thesimplekid
2025-03-05 10:32:41 +00:00
committed by GitHub
parent 0cd1d6a194
commit e84d6ea7ab
51 changed files with 426 additions and 1037 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
crates/cdk-mintd/src/config.rs
View File

@@ -47,7 +47,6 @@ pub enum LnBackend {
#[default]
None,
Cln,
Strike,
LNbits,
FakeWallet,
Phoenixd,
@@ -60,7 +59,6 @@ impl std::str::FromStr for LnBackend {
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.to_lowercase().as_str() {
"cln" => Ok(LnBackend::Cln),
"strike" => Ok(LnBackend::Strike),
"lnbits" => Ok(LnBackend::LNbits),
"fakewallet" => Ok(LnBackend::FakeWallet),
"phoenixd" => Ok(LnBackend::Phoenixd),
@@ -93,12 +91,6 @@ impl Default for Ln {
}
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct Strike {
pub api_key: String,
pub supported_units: Option<Vec<CurrencyUnit>>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct LNbits {
pub admin_api_key: String,
@@ -172,6 +164,7 @@ fn default_max_delay_time() -> u64 {
pub enum DatabaseEngine {
#[default]
Sqlite,
#[cfg(feature = "redb")]
Redb,
}
@@ -181,6 +174,7 @@ impl std::str::FromStr for DatabaseEngine {
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.to_lowercase().as_str() {
"sqlite" => Ok(DatabaseEngine::Sqlite),
#[cfg(feature = "redb")]
"redb" => Ok(DatabaseEngine::Redb),
_ => Err(format!("Unknown database engine: {}", s)),
}
@@ -199,7 +193,6 @@ pub struct Settings {
pub mint_info: MintInfo,
pub ln: Ln,
pub cln: Option<Cln>,
pub strike: Option<Strike>,
pub lnbits: Option<LNbits>,
pub phoenixd: Option<Phoenixd>,
pub lnd: Option<Lnd>,
@@ -291,10 +284,6 @@ impl Settings {
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"

29
crates/cdk-mintd/src/env_vars.rs
View File

@@ -9,7 +9,7 @@ use cdk::nuts::CurrencyUnit;
use crate::config::MintManagementRpc;
use crate::config::{
Cln, Database, DatabaseEngine, FakeWallet, Info, LNbits, Ln, LnBackend, Lnd, MintInfo,
Phoenixd, Settings, Strike,
Phoenixd, Settings,
};
pub const ENV_WORK_DIR: &str = "CDK_MINTD_WORK_DIR";
@@ -45,9 +45,6 @@ pub const ENV_CLN_RPC_PATH: &str = "CDK_MINTD_CLN_RPC_PATH";
pub const ENV_CLN_BOLT12: &str = "CDK_MINTD_CLN_BOLT12";
pub const ENV_CLN_FEE_PERCENT: &str = "CDK_MINTD_CLN_FEE_PERCENT";
pub const ENV_CLN_RESERVE_FEE_MIN: &str = "CDK_MINTD_CLN_RESERVE_FEE_MIN";
// Strike
pub const ENV_STRIKE_API_KEY: &str = "CDK_MINTD_STRIKE_API_KEY";
pub const ENV_STRIKE_SUPPORTED_UNITS: &str = "CDK_MINTD_STRIKE_SUPPORTED_UNITS";
// LND environment variables
pub const ENV_LND_ADDRESS: &str = "CDK_MINTD_LND_ADDRESS";
pub const ENV_LND_CERT_FILE: &str = "CDK_MINTD_LND_CERT_FILE";
@@ -107,9 +104,6 @@ impl Settings {
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());
}
@@ -298,27 +292,6 @@ impl Cln {
}
}
impl Strike {
pub fn from_env(mut self) -> Self {
// API Key
if let Ok(api_key) = env::var(ENV_STRIKE_API_KEY) {
self.api_key = api_key;
}
// Supported Units - expects comma-separated list
if let Ok(units_str) = env::var(ENV_STRIKE_SUPPORTED_UNITS) {
self.supported_units = Some(
units_str
.split(',')
.filter_map(|s| s.trim().parse().ok())
.collect(),
);
}
self
}
}
impl Lnd {
pub fn from_env(mut self) -> Self {
if let Ok(address) = env::var(ENV_LND_ADDRESS) {

86
crates/cdk-mintd/src/main.rs
View File

@@ -5,15 +5,13 @@
use std::collections::HashMap;
use std::env;
use std::net::SocketAddr;
use std::path::PathBuf;
use std::str::FromStr;
use std::sync::Arc;
use anyhow::{anyhow, bail, Result};
use axum::http::Request;
use axum::middleware::Next;
use axum::response::Response;
use axum::{middleware, Router};
use axum::Router;
use bip39::Mnemonic;
use cdk::cdk_database::{self, MintDatabase};
use cdk::cdk_lightning;
@@ -30,12 +28,15 @@ use cdk_mintd::cli::CLIArgs;
use cdk_mintd::config::{self, DatabaseEngine, LnBackend};
use cdk_mintd::env_vars::ENV_WORK_DIR;
use cdk_mintd::setup::LnBackendSetup;
#[cfg(feature = "redb")]
use cdk_redb::MintRedbDatabase;
use cdk_sqlite::MintSqliteDatabase;
use clap::Parser;
use tokio::sync::Notify;
use tower::ServiceBuilder;
use tower_http::compression::CompressionLayer;
use tower_http::cors::CorsLayer;
use tower_http::decompression::RequestDecompressionLayer;
use tower_http::trace::TraceLayer;
use tracing_subscriber::EnvFilter;
#[cfg(feature = "swagger")]
use utoipa::OpenApi;
@@ -49,10 +50,11 @@ async fn main() -> anyhow::Result<()> {
let sqlx_filter = "sqlx=warn";
let hyper_filter = "hyper=warn";
let h2_filter = "h2=warn";
let tower_http = "tower_http=warn";
let env_filter = EnvFilter::new(format!(
"{},{},{},{}",
default_filter, sqlx_filter, hyper_filter, h2_filter
"{},{},{},{},{}",
default_filter, sqlx_filter, hyper_filter, h2_filter, tower_http
));
tracing_subscriber::fmt().with_env_filter(env_filter).init();
@@ -100,6 +102,7 @@ async fn main() -> anyhow::Result<()> {
Arc::new(sqlite_db)
}
#[cfg(feature = "redb")]
DatabaseEngine::Redb => {
let redb_path = work_dir.join("cdk-mintd.redb");
Arc::new(MintRedbDatabase::new(&redb_path)?)
@@ -180,29 +183,6 @@ async fn main() -> anyhow::Result<()> {
mint_builder = mint_builder.add_supported_websockets(nut17_supported);
}
LnBackend::Strike => {
let strike_settings = settings.clone().strike.expect("Checked on config load");
for unit in strike_settings
.clone()
.supported_units
.unwrap_or(vec![CurrencyUnit::Sat])
{
let strike = strike_settings
.setup(&mut ln_routers, &settings, unit.clone())
.await?;
mint_builder = mint_builder.add_ln_backend(
unit.clone(),
PaymentMethod::Bolt11,
mint_melt_limits,
Arc::new(strike),
);
let nut17_supported = SupportedMethods::new(PaymentMethod::Bolt11, unit);
mint_builder = mint_builder.add_supported_websockets(nut17_supported);
}
}
LnBackend::LNbits => {
let lnbits_settings = settings.clone().lnbits.expect("Checked on config load");
let lnbits = lnbits_settings
@@ -341,9 +321,12 @@ async fn main() -> anyhow::Result<()> {
let mut mint_service = Router::new()
.merge(v1_service)
.layer(CompressionLayer::new())
.layer(middleware::from_fn(logging_middleware))
.layer(CorsLayer::permissive());
.layer(
ServiceBuilder::new()
.layer(RequestDecompressionLayer::new())
.layer(CompressionLayer::new()),
)
.layer(TraceLayer::new_for_http());
#[cfg(feature = "swagger")]
{
@@ -406,13 +389,13 @@ async fn main() -> anyhow::Result<()> {
mint.set_quote_ttl(QuoteTTL::new(10_000, 10_000)).await?;
}
let axum_result = axum::Server::bind(
&format!("{}:{}", listen_addr, listen_port)
.as_str()
.parse()?,
)
.serve(mint_service.into_make_service())
.with_graceful_shutdown(shutdown_signal());
let socket_addr = SocketAddr::from_str(&format!("{}:{}", listen_addr, listen_port))?;
let listener = tokio::net::TcpListener::bind(socket_addr).await?;
tracing::debug!("listening on {}", listener.local_addr().unwrap());
let axum_result = axum::serve(listener, mint_service).with_graceful_shutdown(shutdown_signal());
match axum_result.await {
Ok(_) => {
@@ -437,29 +420,6 @@ async fn main() -> anyhow::Result<()> {
Ok(())
}
/// Logs infos about the request and the response
async fn logging_middleware<B>(req: Request<B>, next: Next<B>) -> Response {
let start = std::time::Instant::now();
let path = req.uri().path().to_owned();
let method = req.method().clone();
let response = next.run(req).await;
let duration = start.elapsed();
let status = response.status();
let compression = response
.headers()
.get("content-encoding")
.map(|h| h.to_str().unwrap_or("none"))
.unwrap_or("none");
tracing::trace!(
"Request: {method} {path} | Status: {status} | Compression: {compression} | Duration: {duration:?}",
);
response
}
fn work_dir() -> Result<PathBuf> {
let home_dir = home::home_dir().ok_or(anyhow!("Unknown home dir"))?;
let dir = home_dir.join(".cdk-mintd");

37
crates/cdk-mintd/src/setup.rs
View File

@@ -2,7 +2,8 @@ use std::collections::{HashMap, HashSet};
use std::sync::Arc;
use anyhow::{anyhow, bail};
use axum::{async_trait, Router};
use async_trait::async_trait;
use axum::Router;
use bip39::rand::{thread_rng, Rng};
use cdk::cdk_lightning::MintLightning;
use cdk::mint::FeeReserve;
@@ -50,40 +51,6 @@ impl LnBackendSetup for config::Cln {
}
}
#[async_trait]
impl LnBackendSetup for config::Strike {
async fn setup(
&self,
routers: &mut Vec<Router>,
settings: &Settings,
unit: CurrencyUnit,
) -> anyhow::Result<cdk_strike::Strike> {
let api_key = &self.api_key;
// Channel used for strike web hook
let (sender, receiver) = tokio::sync::mpsc::channel(8);
let webhook_endpoint = format!("/webhook/{}/invoice", unit);
let mint_url: MintUrl = settings.info.url.parse()?;
let webhook_url = mint_url.join(&webhook_endpoint)?;
let strike = cdk_strike::Strike::new(
api_key.clone(),
unit,
Arc::new(Mutex::new(Some(receiver))),
webhook_url.to_string(),
)
.await?;
let router = strike
.create_invoice_webhook(&webhook_endpoint, sender)
.await?;
routers.push(router);
Ok(strike)
}
}
#[async_trait]
impl LnBackendSetup for config::LNbits {
async fn setup(