cashubtc · thesimplekid · Sep 27, 2024 · Oct 25, 2024 · Oct 26, 2024 · Oct 26, 2024
diff --git a/bindings/cdk-js/src/nuts/nut04.rs b/bindings/cdk-js/src/nuts/nut04.rs
@@ -88,10  88,18 @@ impl From<MintBolt11Request> for JsMintBolt11Request {
 impl JsMintBolt11Request {
     /// Try From Base 64 String
     #[wasm_bindgen(constructor)]
-    pub fn new(quote: String, outputs: JsValue) -> Result<JsMintBolt11Request> {
     pub fn new(
         quote: String,
         outputs: JsValue,
         witness: Option<String>,
     ) -> Result<JsMintBolt11Request> {
         let outputs = serde_wasm_bindgen::from_value(outputs).map_err(into_err)?;
         Ok(JsMintBolt11Request {
-            inner: MintBolt11Request { quote, outputs },
             inner: MintBolt11Request {
                 quote,
                 outputs,
                 witness,
             },
         })
     }
 

diff --git a/bindings/cdk-js/src/wallet.rs b/bindings/cdk-js/src/wallet.rs
@@ -93,7  93,7 @@ impl JsWallet {
     ) -> Result<JsMintQuote> {
         let quote = self
             .inner
-            .mint_quote(amount.into(), description)
             .mint_quote(amount.into(), description, None)
             .await
             .map_err(into_err)?;
 
@@ -142,7  142,7 @@ impl JsWallet {
 
         Ok(self
             .inner
-            .mint(&quote_id, target, conditions)
             .mint(&quote_id, target, conditions, None)
             .await
             .map_err(into_err)?
             .into())

diff --git a/crates/cdk-axum/src/bolt12_router.rs b/crates/cdk-axum/src/bolt12_router.rs
@@ -0,0  1,129 @@
 use anyhow::Result;
 use axum::extract::{Json, Path, State};
 use axum::response::Response;
 use cdk::nuts::{
     MeltBolt12Request, MeltQuoteBolt11Response, MeltQuoteBolt12Request, MintBolt11Request,
     MintBolt11Response, MintQuoteBolt12Request, MintQuoteBolt12Response,
 };
 
 use crate::{into_response, MintState};
 
 #[cfg_attr(feature = "swagger", utoipa::path(
     get,
     context_path = "/v1",
     path = "/mint/quote/bolt12",
     responses(
         (status = 200, description = "Successful response", body = MintQuoteBolt12Response, content_type = "application/json")
     )
 ))]
 /// Get mint bolt12 quote
 pub async fn get_mint_bolt12_quote(
     State(state): State<MintState>,
     Json(payload): Json<MintQuoteBolt12Request>,
 ) -> Result<Json<MintQuoteBolt12Response>, Response> {
     let quote = state
         .mint
         .get_mint_bolt12_quote(payload)
         .await
         .map_err(into_response)?;
 
     Ok(Json(quote))
 }
 
 #[cfg_attr(feature = "swagger", utoipa::path(
     get,
     context_path = "/v1",
     path = "/mint/quote/bolt12/{quote_id}",
     params(
         ("quote_id" = String, description = "The quote ID"),
     ),
     responses(
         (status = 200, description = "Successful response", body = MintQuoteBolt12Response, content_type = "application/json"),
         (status = 500, description = "Server error", body = ErrorResponse, content_type = "application/json")
     )
 ))]
 /// Get mint bolt12 quote
 pub async fn get_check_mint_bolt12_quote(
     State(state): State<MintState>,
     Path(quote_id): Path<String>,
 ) -> Result<Json<MintQuoteBolt12Response>, Response> {
     let quote = state
         .mint
         .check_mint_bolt12_quote(&quote_id)
         .await
         .map_err(into_response)?;
 
     Ok(Json(quote))
 }
 
 #[cfg_attr(feature = "swagger", utoipa::path(
     post,
     context_path = "/v1",
     path = "/mint/bolt12",
     request_body(content = MintBolt11Request, description = "Request params", content_type = "application/json"),
     responses(
         (status = 200, description = "Successful response", body = MintBolt11Response, content_type = "application/json"),
         (status = 500, description = "Server error", body = ErrorResponse, content_type = "application/json")
     )
 ))]
 /// Request a quote for melting tokens
 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))
 }
 
 #[cfg_attr(feature = "swagger", utoipa::path(
     post,
     context_path = "/v1",
     path = "/melt/quote/bolt12",
     request_body(content = MeltQuoteBolt12Request, description = "Quote params", content_type = "application/json"),
     responses(
         (status = 200, description = "Successful response", body = MeltQuoteBolt11Response, content_type = "application/json"),
         (status = 500, description = "Server error", body = ErrorResponse, content_type = "application/json")
     )
 ))]
 pub async fn get_melt_bolt12_quote(
     State(state): State<MintState>,
     Json(payload): Json<MeltQuoteBolt12Request>,
 ) -> Result<Json<MeltQuoteBolt11Response>, Response> {
     let quote = state
         .mint
         .get_melt_bolt12_quote(&payload)
         .await
         .map_err(into_response)?;
 
     Ok(Json(quote))
 }
 
 #[cfg_attr(feature = "swagger", utoipa::path(
     post,
     context_path = "/v1",
     path = "/melt/bolt12",
     request_body(content = MeltBolt12Request, description = "Melt params", content_type = "application/json"),
     responses(
         (status = 200, description = "Successful response", body = MeltQuoteBolt11Response, content_type = "application/json"),
         (status = 500, description = "Server error", body = ErrorResponse, content_type = "application/json")
     )
 ))]
 /// Melt tokens for a Bitcoin payment that the mint will make for the user in exchange
 ///
 /// Requests tokens to be destroyed and sent out via Lightning.
 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))
 }
diff --git a/crates/cdk-axum/src/lib.rs b/crates/cdk-axum/src/lib.rs
@@ -9,10  9,15 @@ use std::time::Duration;
 use anyhow::Result;
 use axum::routing::{get, post};
 use axum::Router;
 use bolt12_router::{
     get_check_mint_bolt12_quote, get_melt_bolt12_quote, get_mint_bolt12_quote, post_melt_bolt12,
     post_mint_bolt12,
 };
 use cdk::mint::Mint;
 use moka::future::Cache;
 use router_handlers::*;
 
 mod bolt12_router;
 mod router_handlers;
 mod ws;
 
@@ -130,7  135,12 @@ pub struct MintState {
 pub struct ApiDocV1;
 
 /// 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()
@@ -140,7  150,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))
@@ -162,7  172,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_bolt12_quote),
         )
         .route("/mint/bolt12", post(post_mint_bolt12))
         .with_state(state)
 }
diff --git a/crates/cdk-axum/src/router_handlers.rs b/crates/cdk-axum/src/router_handlers.rs
@@ -157,8  157,6 @@ pub async fn post_mint_bolt11_quote(
         (status = 500, description = "Server error", body = ErrorResponse, content_type = "application/json")
     )
 ))]
-/// Get mint quote by ID
-///
 /// Get mint quote state.
 pub async fn get_check_mint_bolt11_quote(
     State(state): State<MintState>,
@@ -283,11  281,7 @@ pub async fn post_melt_bolt11(
     State(state): State<MintState>,
     Json(payload): Json<MeltBolt11Request>,
 ) -> Result<Json<MeltQuoteBolt11Response>, Response> {
-    let res = state
-        .mint
-        .melt_bolt11(&payload)
-        .await
-        .map_err(into_response)?;
     let res = state.mint.melt(&payload).await.map_err(into_response)?;
 
     Ok(Json(res))
 }

diff --git a/crates/cdk-cli/src/main.rs b/crates/cdk-cli/src/main.rs
@@ -25,7  25,7 @@ const DEFAULT_WORK_DIR: &str = ".cdk-cli";
 #[derive(Parser)]
 #[command(name = "cashu-tool")]
 #[command(author = "thesimplekid <[email protected]>")]
-#[command(version = "0.1.0")]
 #[command(version = "0.4.0")]
 #[command(author, version, about, long_about = None)]
 struct Cli {
     /// Database engine to use (sqlite/redb)
@@ -64,6  64,8 @@ enum Commands {
     MintInfo(sub_commands::mint_info::MintInfoSubcommand),
     /// Mint proofs via bolt11
     Mint(sub_commands::mint::MintSubCommand),
     /// Remint
     ReMint(sub_commands::remint_bolt12::ReMintSubCommand),
     /// Burn Spent tokens
     Burn(sub_commands::burn::BurnSubCommand),
     /// Restore proofs from seed
@@ -219,5  221,14 @@ async fn main() -> Result<()> {
         Commands::CreateRequest(sub_command_args) => {
             sub_commands::create_request::create_request(&multi_mint_wallet, sub_command_args).await
         }
         Commands::ReMint(sub_command_args) => {
             sub_commands::remint_bolt12::remint(
                 &multi_mint_wallet,
                 &mnemonic.to_seed_normalized(""),
                 localstore,
                 sub_command_args,
             )
             .await
         }
     }
 }
diff --git a/crates/cdk-cli/src/sub_commands/melt.rs b/crates/cdk-cli/src/sub_commands/melt.rs
@@ -3,9  3,9 @@ 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 clap::Args;
 
 use crate::sub_commands::balance::mint_balances;
@@ -15,13  15,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  50,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);