Merge pull request cashubtc#874 from thesimplekid/bolt12_2

Bolt12 2

Author: thesimplekid

Cargo.toml

@@ -61,6 +61,7 @@ ciborium = { version = "0.2.2", default-features = false, features = ["std"] }
 cbor-diag = "0.1.12"
 futures = { version = "0.3.28", default-features = false, features = ["async-await"] }
 lightning-invoice = { version = "0.33.0", features = ["serde", "std"] }
+lightning = { version = "0.1.2", default-features = false, features = ["std"]}
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 thiserror = { version = "2" }

crates/cashu/Cargo.toml

@@ -26,6 +26,7 @@ ciborium.workspace = true
 once_cell.workspace = true
 serde.workspace = true
 lightning-invoice.workspace = true
+lightning.workspace = true
 thiserror.workspace = true
 tracing.workspace = true
 url.workspace = true

crates/cashu/src/amount.rs

@@ -6,6 +6,7 @@ use std::cmp::Ordering;
 use std::fmt;
 use std::str::FromStr;
 
+use lightning::offers::offer::Offer;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
@@ -26,6 +27,12 @@ pub enum Error {
     /// Invalid amount
     #[error("Invalid Amount: {0}")]
     InvalidAmount(String),
+    /// Amount undefined
+    #[error("Amount undefined")]
+    AmountUndefined,
+    /// Utf8 parse error
+    #[error(transparent)]
+    Utf8ParseError(#[from] std::string::FromUtf8Error),
 }
 
 /// Amount can be any unit
@@ -181,6 +188,24 @@ impl Amount {
     ) -> Result<Amount, Error> {
         to_unit(self.0, current_unit, target_unit)
     }
+
+    /// Convert to i64
+    pub fn to_i64(self) -> Option<i64> {
+        if self.0 <= i64::MAX as u64 {
+            Some(self.0 as i64)
+        } else {
+            None
+        }
+    }
+
+    /// Create from i64, returning None if negative
+    pub fn from_i64(value: i64) -> Option<Self> {
+        if value >= 0 {
+            Some(Amount(value as u64))
+        } else {
+            None
+        }
+    }
 }
 
 impl Default for Amount {
@@ -273,6 +298,27 @@ impl std::ops::Div for Amount {
     }
 }
 
+/// Convert offer to amount in unit
+pub fn amount_for_offer(offer: &Offer, unit: &CurrencyUnit) -> Result<Amount, Error> {
+    let offer_amount = offer.amount().ok_or(Error::AmountUndefined)?;
+
+    let (amount, currency) = match offer_amount {
+        lightning::offers::offer::Amount::Bitcoin { amount_msats } => {
+            (amount_msats, CurrencyUnit::Msat)
+        }
+        lightning::offers::offer::Amount::Currency {
+            iso4217_code,
+            amount,
+        } => (
+            amount,
+            CurrencyUnit::from_str(&String::from_utf8(iso4217_code.to_vec())?)
+                .map_err(|_| Error::CannotConvertUnits)?,
+        ),
+    };
+
+    to_unit(amount, &currency, unit).map_err(|_err| Error::CannotConvertUnits)
+}
+
 /// Kinds of targeting that are supported
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Default, Serialize, Deserialize)]
 pub enum SplitTarget {

crates/cashu/src/nuts/auth/nut21.rs

@@ -149,6 +149,18 @@ pub enum RoutePath {
     /// Mint Blind Auth
     #[serde(rename = "/v1/auth/blind/mint")]
     MintBlindAuth,
+    /// Bolt12 Mint Quote
+    #[serde(rename = "/v1/mint/quote/bolt12")]
+    MintQuoteBolt12,
+    /// Bolt12 Mint
+    #[serde(rename = "/v1/mint/bolt12")]
+    MintBolt12,
+    /// Bolt12 Melt Quote
+    #[serde(rename = "/v1/melt/quote/bolt12")]
+    MeltQuoteBolt12,
+    /// Bolt12 Quote
+    #[serde(rename = "/v1/melt/bolt12")]
+    MeltBolt12,
 }
 
 /// Returns [`RoutePath`]s that match regex
@@ -195,6 +207,8 @@ mod tests {
         assert!(paths.contains(&RoutePath::Checkstate));
         assert!(paths.contains(&RoutePath::Restore));
         assert!(paths.contains(&RoutePath::MintBlindAuth));
+        assert!(paths.contains(&RoutePath::MintQuoteBolt12));
+        assert!(paths.contains(&RoutePath::MintBolt12));
     }
 
     #[test]
@@ -203,13 +217,17 @@ mod tests {
         let paths = matching_route_paths("^/v1/mint/.*").unwrap();
 
         // Should match only mint paths
-        assert_eq!(paths.len(), 2);
+        assert_eq!(paths.len(), 4);
         assert!(paths.contains(&RoutePath::MintQuoteBolt11));
         assert!(paths.contains(&RoutePath::MintBolt11));
+        assert!(paths.contains(&RoutePath::MintQuoteBolt12));
+        assert!(paths.contains(&RoutePath::MintBolt12));
 
         // Should not match other paths
         assert!(!paths.contains(&RoutePath::MeltQuoteBolt11));
         assert!(!paths.contains(&RoutePath::MeltBolt11));
+        assert!(!paths.contains(&RoutePath::MeltQuoteBolt12));
+        assert!(!paths.contains(&RoutePath::MeltBolt12));
         assert!(!paths.contains(&RoutePath::Swap));
     }
 
@@ -219,9 +237,11 @@ mod tests {
         let paths = matching_route_paths(".*/quote/.*").unwrap();
 
         // Should match only quote paths
-        assert_eq!(paths.len(), 2);
+        assert_eq!(paths.len(), 4);
         assert!(paths.contains(&RoutePath::MintQuoteBolt11));
         assert!(paths.contains(&RoutePath::MeltQuoteBolt11));
+        assert!(paths.contains(&RoutePath::MintQuoteBolt12));
+        assert!(paths.contains(&RoutePath::MeltQuoteBolt12));
 
         // Should not match non-quote paths
         assert!(!paths.contains(&RoutePath::MintBolt11));
@@ -336,12 +356,14 @@ mod tests {
             "https://example.com/.well-known/openid-configuration"
         );
         assert_eq!(settings.client_id, "client123");
-        assert_eq!(settings.protected_endpoints.len(), 3); // 2 mint paths + 1 swap path
+        assert_eq!(settings.protected_endpoints.len(), 5); // 3 mint paths + 1 swap path
 
         let expected_protected: HashSet<ProtectedEndpoint> = HashSet::from_iter(vec![
             ProtectedEndpoint::new(Method::Post, RoutePath::Swap),
             ProtectedEndpoint::new(Method::Get, RoutePath::MintBolt11),
             ProtectedEndpoint::new(Method::Get, RoutePath::MintQuoteBolt11),
+            ProtectedEndpoint::new(Method::Get, RoutePath::MintQuoteBolt12),
+            ProtectedEndpoint::new(Method::Get, RoutePath::MintBolt12),
         ]);
 
         let deserlized_protected = settings.protected_endpoints.into_iter().collect();

crates/cashu/src/nuts/auth/nut22.rs

@@ -330,12 +330,14 @@ mod tests {
         let settings: Settings = serde_json::from_str(json).unwrap();
 
         assert_eq!(settings.bat_max_mint, 5);
-        assert_eq!(settings.protected_endpoints.len(), 3); // 2 mint paths + 1 swap path
+        assert_eq!(settings.protected_endpoints.len(), 5); // 4 mint paths + 1 swap path
 
         let expected_protected: HashSet<ProtectedEndpoint> = HashSet::from_iter(vec![
             ProtectedEndpoint::new(Method::Post, RoutePath::Swap),
             ProtectedEndpoint::new(Method::Get, RoutePath::MintBolt11),
             ProtectedEndpoint::new(Method::Get, RoutePath::MintQuoteBolt11),
+            ProtectedEndpoint::new(Method::Get, RoutePath::MintQuoteBolt12),
+            ProtectedEndpoint::new(Method::Get, RoutePath::MintBolt12),
         ]);
 
         let deserialized_protected = settings.protected_endpoints.into_iter().collect();

crates/cashu/src/nuts/mod.rs

@@ -24,6 +24,7 @@ pub mod nut18;
 pub mod nut19;
 pub mod nut20;
 pub mod nut23;
+pub mod nut24;
 
 #[cfg(feature = "auth")]
 mod auth;
@@ -67,3 +68,4 @@ pub use nut23::{
     MeltOptions, MeltQuoteBolt11Request, MeltQuoteBolt11Response, MintQuoteBolt11Request,
     MintQuoteBolt11Response, QuoteState as MintQuoteState,
 };
+pub use nut24::{MeltQuoteBolt12Request, MintQuoteBolt12Request, MintQuoteBolt12Response};

crates/cashu/src/nuts/nut00/mod.rs

@@ -641,13 +641,14 @@ impl<'de> Deserialize<'de> for CurrencyUnit {
 }
 
 /// Payment Method
-#[non_exhaustive]
 #[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "swagger", derive(utoipa::ToSchema))]
 pub enum PaymentMethod {
     /// Bolt11 payment type
     #[default]
     Bolt11,
+    /// Bolt12
+    Bolt12,
     /// Custom
     Custom(String),
 }
@@ -657,6 +658,7 @@ impl FromStr for PaymentMethod {
     fn from_str(value: &str) -> Result<Self, Self::Err> {
         match value.to_lowercase().as_str() {
             "bolt11" => Ok(Self::Bolt11),
+            "bolt12" => Ok(Self::Bolt12),
             c => Ok(Self::Custom(c.to_string())),
         }
     }
@@ -666,6 +668,7 @@ impl fmt::Display for PaymentMethod {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             PaymentMethod::Bolt11 => write!(f, "bolt11"),
+            PaymentMethod::Bolt12 => write!(f, "bolt12"),
             PaymentMethod::Custom(p) => write!(f, "{p}"),
         }
     }

crates/cashu/src/nuts/nut04.rs

@@ -291,6 +291,16 @@ impl Settings {
             .position(|settings| &settings.method == method && &settings.unit == unit)
             .map(|index| self.methods.remove(index))
     }
+
+    /// Supported nut04 methods
+    pub fn supported_methods(&self) -> Vec<&PaymentMethod> {
+        self.methods.iter().map(|a| &a.method).collect()
+    }
+
+    /// Supported nut04 units
+    pub fn supported_units(&self) -> Vec<&CurrencyUnit> {
+        self.methods.iter().map(|s| &s.unit).collect()
+    }
 }
 
 #[cfg(test)]

crates/cashu/src/nuts/nut05.rs

@@ -105,6 +105,11 @@ impl TryFrom<MeltRequest<String>> for MeltRequest<Uuid> {
 
 // Basic implementation without trait bounds
 impl<Q> MeltRequest<Q> {
+    /// Quote Id
+    pub fn quote_id(&self) -> &Q {
+        &self.quote
+    }
+
     /// Get inputs (proofs)
     pub fn inputs(&self) -> &Proofs {
         &self.inputs
@@ -132,7 +137,7 @@ impl<Q: Serialize + DeserializeOwned> MeltRequest<Q> {
     }
 
     /// Total [`Amount`] of [`Proofs`]
-    pub fn proofs_amount(&self) -> Result<Amount, Error> {
+    pub fn inputs_amount(&self) -> Result<Amount, Error> {
         Amount::try_sum(self.inputs.iter().map(|proof| proof.amount))
             .map_err(|_| Error::AmountOverflow)
     }
@@ -355,6 +360,18 @@ pub struct Settings {
     pub disabled: bool,
 }
 
+impl Settings {
+    /// Supported nut05 methods
+    pub fn supported_methods(&self) -> Vec<&PaymentMethod> {
+        self.methods.iter().map(|a| &a.method).collect()
+    }
+
+    /// Supported nut05 units
+    pub fn supported_units(&self) -> Vec<&CurrencyUnit> {
+        self.methods.iter().map(|s| &s.unit).collect()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use serde_json::{from_str, json, to_string};

crates/cashu/src/nuts/nut17/mod.rs

@@ -9,6 +9,7 @@ use super::PublicKey;
 use crate::nuts::{
     CurrencyUnit, MeltQuoteBolt11Response, MintQuoteBolt11Response, PaymentMethod, ProofState,
 };
+use crate::MintQuoteBolt12Response;
 
 pub mod ws;
 
@@ -69,6 +70,21 @@ impl SupportedMethods {
             commands,
         }
     }
+
+    /// Create [`SupportedMethods`] for Bolt12 with all supported commands
+    pub fn default_bolt12(unit: CurrencyUnit) -> Self {
+        let commands = vec![
+            WsCommand::Bolt12MintQuote,
+            WsCommand::Bolt12MeltQuote,
+            WsCommand::ProofState,
+        ];
+
+        Self {
+            method: PaymentMethod::Bolt12,
+            unit,
+            commands,
+        }
+    }
 }
 
 /// WebSocket commands supported by the Cashu mint
@@ -82,11 +98,23 @@ pub enum WsCommand {
     /// Command to request a Lightning payment for melting tokens
     #[serde(rename = "bolt11_melt_quote")]
     Bolt11MeltQuote,
+    /// Websocket support for Bolt12 Mint Quote
+    #[serde(rename = "bolt12_mint_quote")]
+    Bolt12MintQuote,
+    /// Websocket support for Bolt12 Melt Quote
+    #[serde(rename = "bolt12_melt_quote")]
+    Bolt12MeltQuote,
     /// Command to check the state of a proof
     #[serde(rename = "proof_state")]
     ProofState,
 }
 
+impl<T> From<MintQuoteBolt12Response<T>> for NotificationPayload<T> {
+    fn from(mint_quote: MintQuoteBolt12Response<T>) -> NotificationPayload<T> {
+        NotificationPayload::MintQuoteBolt12Response(mint_quote)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(bound = "T: Serialize + DeserializeOwned")]
 #[serde(untagged)]
@@ -98,6 +126,8 @@ pub enum NotificationPayload<T> {
     MeltQuoteBolt11Response(MeltQuoteBolt11Response<T>),
     /// Mint Quote Bolt11 Response
     MintQuoteBolt11Response(MintQuoteBolt11Response<T>),
+    /// Mint Quote Bolt12 Response
+    MintQuoteBolt12Response(MintQuoteBolt12Response<T>),
 }
 
 impl<T> From<ProofState> for NotificationPayload<T> {
@@ -128,6 +158,10 @@ pub enum Notification {
     MeltQuoteBolt11(Uuid),
     /// MintQuote id is an Uuid
     MintQuoteBolt11(Uuid),
+    /// MintQuote id is an Uuid
+    MintQuoteBolt12(Uuid),
+    /// MintQuote id is an Uuid
+    MeltQuoteBolt12(Uuid),
 }
 
 /// Kind