feat: bolt12

crates/cdk-axum/src/lib.rs

@@ -23,7 +23,12 @@ pub struct MintState {
 }
 
 /// Create mint [`Router`] with required endpoints for cashu mint
-pub async fn create_mint_router(mint: Arc<Mint>, cache_ttl: u64, cache_tti: u64) -> Result<Router> {
+pub async fn create_mint_router(
+    mint: Arc<Mint>,
+    cache_ttl: u64,
+    cache_tti: u64,
+    include_bolt12: bool,
+) -> Result<Router> {
     let state = MintState {
         mint,
         cache: Cache::builder()
@@ -33,7 +38,7 @@ pub async fn create_mint_router(mint: Arc<Mint>, cache_ttl: u64, cache_tti: u64)
             .build(),
     };
 
-    let v1_router = Router::new()
+    let mut v1_router = Router::new()
         .route("/keys", get(get_keys))
         .route("/keysets", get(get_keysets))
         .route("/keys/:keyset_id", get(get_keyset_pubkeys))
@@ -54,7 +59,32 @@ pub async fn create_mint_router(mint: Arc<Mint>, cache_ttl: u64, cache_tti: u64)
         .route("/info", get(get_mint_info))
         .route("/restore", post(post_restore));
 
+    // Conditionally create and merge bolt12_router
+    if include_bolt12 {
+        let bolt12_router = create_bolt12_router(state.clone());
+        //v1_router = bolt12_router.merge(v1_router);
+        v1_router = v1_router.merge(bolt12_router);
+    }
+
+    // Nest the combined router under "/v1"
     let mint_router = Router::new().nest("/v1", v1_router).with_state(state);
 
     Ok(mint_router)
 }
+
+fn create_bolt12_router(state: MintState) -> Router<MintState> {
+    Router::new()
+        .route("/melt/quote/bolt12", post(get_melt_bolt12_quote))
+        .route(
+            "/melt/quote/bolt12/:quote_id",
+            get(get_check_melt_bolt11_quote),
+        )
+        .route("/melt/bolt12", post(post_melt_bolt12))
+        .route("/mint/quote/bolt12", post(get_mint_bolt12_quote))
+        .route(
+            "/mint/quote/bolt12/:quote_id",
+            get(get_check_mint_bolt11_quote),
+        )
+        .route("/mint/bolt12", post(post_mint_bolt12))
+        .with_state(state)
+}

crates/cdk-axum/src/router_handlers.rs

@@ -5,9 +5,9 @@ use axum::response::{IntoResponse, Response};
 use cdk::error::ErrorResponse;
 use cdk::nuts::{
     CheckStateRequest, CheckStateResponse, Id, KeysResponse, KeysetResponse, MeltBolt11Request,
-    MeltQuoteBolt11Request, MeltQuoteBolt11Response, MintBolt11Request, MintBolt11Response,
-    MintInfo, MintQuoteBolt11Request, MintQuoteBolt11Response, RestoreRequest, RestoreResponse,
-    SwapRequest, SwapResponse,
+    MeltBolt12Request, MeltQuoteBolt11Request, MeltQuoteBolt11Response, MeltQuoteBolt12Request,
+    MintBolt11Request, MintBolt11Response, MintInfo, MintQuoteBolt11Request,
+    MintQuoteBolt11Response, RestoreRequest, RestoreResponse, SwapRequest, SwapResponse,
 };
 use cdk::util::unix_time;
 use cdk::Error;
@@ -92,6 +92,19 @@ pub async fn get_mint_bolt11_quote(
     Ok(Json(quote))
 }
 
+pub async fn get_mint_bolt12_quote(
+    State(state): State<MintState>,
+    Json(payload): Json<MintQuoteBolt11Request>,
+) -> Result<Json<MintQuoteBolt11Response>, Response> {
+    let quote = state
+        .mint
+        .get_mint_bolt12_quote(payload)
+        .await
+        .map_err(into_response)?;
+
+    Ok(Json(quote))
+}
+
 pub async fn get_check_mint_bolt11_quote(
     State(state): State<MintState>,
     Path(quote_id): Path<String>,
@@ -124,6 +137,22 @@ pub async fn post_mint_bolt11(
     Ok(Json(res))
 }
 
+pub async fn post_mint_bolt12(
+    State(state): State<MintState>,
+    Json(payload): Json<MintBolt11Request>,
+) -> Result<Json<MintBolt11Response>, Response> {
+    let res = state
+        .mint
+        .process_mint_request(payload)
+        .await
+        .map_err(|err| {
+            tracing::error!("Could not process mint: {}", err);
+            into_response(err)
+        })?;
+
+    Ok(Json(res))
+}
+
 pub async fn get_melt_bolt11_quote(
     State(state): State<MintState>,
     Json(payload): Json<MeltQuoteBolt11Request>,
@@ -157,12 +186,30 @@ pub async fn post_melt_bolt11(
     State(state): State<MintState>,
     Json(payload): Json<MeltBolt11Request>,
 ) -> Result<Json<MeltQuoteBolt11Response>, Response> {
-    let res = state
+    let res = state.mint.melt(&payload).await.map_err(into_response)?;
+
+    Ok(Json(res))
+}
+
+pub async fn get_melt_bolt12_quote(
+    State(state): State<MintState>,
+    Json(payload): Json<MeltQuoteBolt12Request>,
+) -> Result<Json<MeltQuoteBolt11Response>, Response> {
+    let quote = state
         .mint
-        .melt_bolt11(&payload)
+        .get_melt_bolt12_quote(&payload)
         .await
         .map_err(into_response)?;
 
+    Ok(Json(quote))
+}
+
+pub async fn post_melt_bolt12(
+    State(state): State<MintState>,
+    Json(payload): Json<MeltBolt12Request>,
+) -> Result<Json<MeltQuoteBolt11Response>, Response> {
+    let res = state.mint.melt(&payload).await.map_err(into_response)?;
+
     Ok(Json(res))
 }
 

crates/cdk-cli/src/main.rs

@@ -75,7 +75,7 @@ enum Commands {
 #[tokio::main]
 async fn main() -> Result<()> {
     let args: Cli = Cli::parse();
-    let default_filter = args.log_level;
+    let default_filter = "debug";
 
     let sqlx_filter = "sqlx=warn";
 

crates/cdk-cli/src/sub_commands/melt.rs

@@ -3,9 +3,10 @@ use std::io::Write;
 use std::str::FromStr;
 
 use anyhow::{bail, Result};
-use cdk::nuts::CurrencyUnit;
+use cdk::amount::Amount;
+use cdk::nuts::{CurrencyUnit, PaymentMethod};
 use cdk::wallet::multi_mint_wallet::{MultiMintWallet, WalletKey};
-use cdk::Bolt11Invoice;
+// use cdk::Bolt11Invoice;
 use clap::Args;
 
 use crate::sub_commands::balance::mint_balances;
@@ -15,13 +16,19 @@ pub struct MeltSubCommand {
     /// Currency unit e.g. sat
     #[arg(default_value = "sat")]
     unit: String,
+    /// Payment method
+    #[arg(short, long, default_value = "bolt11")]
+    method: String,
+    /// Amount
+    #[arg(short, long)]
+    amount: Option<u64>,
 }
 
 pub async fn pay(
     multi_mint_wallet: &MultiMintWallet,
     sub_command_args: &MeltSubCommand,
 ) -> Result<()> {
-    let unit = CurrencyUnit::from_str(&sub_command_args.unit)?;
+    let unit = CurrencyUnit::from_str(&sub_command_args.unit).unwrap();
     let mints_amounts = mint_balances(multi_mint_wallet, &unit).await?;
 
     println!("Enter mint number to melt from");
@@ -44,22 +51,36 @@ pub async fn pay(
         .await
         .expect("Known wallet");
 
-    println!("Enter bolt11 invoice request");
+    let method = PaymentMethod::from_str(&sub_command_args.method)?;
+    match method {
+        PaymentMethod::Bolt11 => {
+            println!("Enter bolt11 invoice request");
+        }
+        PaymentMethod::Bolt12 => {
+            println!("Enter bolt12 invoice request");
+        }
+        _ => panic!("Unknown payment method"),
+    }
 
     let mut user_input = String::new();
     let stdin = io::stdin();
     io::stdout().flush().unwrap();
     stdin.read_line(&mut user_input)?;
-    let bolt11 = Bolt11Invoice::from_str(user_input.trim())?;
-
-    if bolt11
-        .amount_milli_satoshis()
-        .unwrap()
-        .gt(&(<cdk::Amount as Into<u64>>::into(mints_amounts[mint_number].1) * 1000_u64))
-    {
-        bail!("Not enough funds");
-    }
-    let quote = wallet.melt_quote(bolt11.to_string(), None).await?;
+
+    let quote = match method {
+        PaymentMethod::Bolt11 => {
+            wallet
+                .melt_quote(user_input.trim().to_string(), None)
+                .await?
+        }
+        PaymentMethod::Bolt12 => {
+            let amount = sub_command_args.amount.map(Amount::from);
+            wallet
+                .melt_bolt12_quote(user_input.trim().to_string(), amount)
+                .await?
+        }
+        _ => panic!("Unsupported payment methof"),
+    };
 
     println!("{:?}", quote);
 

crates/cdk-cli/src/sub_commands/mint.rs

@@ -6,7 +6,7 @@ use anyhow::Result;
 use cdk::amount::SplitTarget;
 use cdk::cdk_database::{Error, WalletDatabase};
 use cdk::mint_url::MintUrl;
-use cdk::nuts::{CurrencyUnit, MintQuoteState};
+use cdk::nuts::{CurrencyUnit, MintQuoteState, PaymentMethod};
 use cdk::wallet::multi_mint_wallet::WalletKey;
 use cdk::wallet::{MultiMintWallet, Wallet};
 use cdk::Amount;
@@ -21,8 +21,11 @@ pub struct MintSubCommand {
     /// Amount
     amount: u64,
     /// Currency unit e.g. sat
-    #[arg(default_value = "sat")]
+    #[arg(short, long, default_value = "sat")]
     unit: String,
+    /// Payment method
+    #[arg(long, default_value = "bolt11")]
+    method: String,
     /// Quote description
     #[serde(skip_serializing_if = "Option::is_none")]
     description: Option<String>,
@@ -51,9 +54,22 @@ pub async fn mint(
         }
     };
 
-    let quote = wallet
-        .mint_quote(Amount::from(sub_command_args.amount), description)
-        .await?;
+    let method = PaymentMethod::from_str(&sub_command_args.method)?;
+
+    let quote = match method {
+        PaymentMethod::Bolt11 => {
+            println!("Bolt11");
+            wallet
+                .mint_quote(Amount::from(sub_command_args.amount), description)
+                .await?
+        }
+        PaymentMethod::Bolt12 => {
+            wallet
+                .mint_bolt12_quote(Amount::from(sub_command_args.amount), description)
+                .await?
+        }
+        _ => panic!("Unsupported unit"),
+    };
 
     println!("Quote: {:#?}", quote);
 

crates/cdk-cln/Cargo.toml

@@ -14,6 +14,7 @@ async-trait = "0.1"
 bitcoin = { version = "0.32.2", default-features = false }
 cdk = { path = "../cdk", version = "0.4.0", default-features = false, features = ["mint"] }
 cln-rpc = "0.2.0"
+lightning = { version = "0.0.124", default-features = false, features = ["std"]}
 futures = { version = "0.3.28", default-features = false }
 tokio = { version = "1", default-features = false }
 tokio-util = { version = "0.7.11", default-features = false }

crates/cdk-cln/src/error.rs

@@ -17,6 +17,9 @@ pub enum Error {
     /// Invalid payment hash
     #[error("Invalid hash")]
     InvalidHash,
+    /// Wrong payment type
+    #[error("Wrong payment type")]
+    WrongPaymentType,
     /// Cln Error
     #[error(transparent)]
     Cln(#[from] cln_rpc::Error),