Merge branch 'bolt12-4'

RCasatta · RCasatta · commit 1d36b194a900 · 2026-03-26T12:46:49.000+01:00
diff --git a/lwk_boltz/src/lib.rs b/lwk_boltz/src/lib.rs
@@ -880,6 +880,24 @@ pub fn parse_bolt12_invoice(bolt12_invoice: &str) -> Result<Bolt12Invoice, Error
     Ok(lightning::offers::invoice::Bolt12Invoice::try_from(data)?)
 }
 
+pub fn display_bolt12_invoice(bolt12_invoice: &Bolt12Invoice) -> String {
+    use bech32::ToBase32;
+    use lightning::util::ser::Writeable;
+
+    // Serialize the invoice to bytes using the Writeable trait
+    let mut bytes = Vec::new();
+    bolt12_invoice
+        .write(&mut bytes)
+        .expect("writing to vec should not fail");
+
+    // Convert bytes to base32
+    let data = bytes.to_base32();
+
+    // Encode with bech32 using the invoice HRP without checksum (matching decode_without_checksum)
+    bech32::encode_without_checksum(BECH32_BOLT12_INVOICE_HRP, data)
+        .expect("encoding valid invoice should succeed")
+}
+
 #[cfg(test)]
 mod tests {
     use std::str::FromStr;
@@ -947,4 +965,19 @@ mod tests {
         let data: Vec<SwapRestoreResponse> = serde_json::from_str(data).unwrap();
         assert_eq!(data.len(), 32);
     }
+
+    #[test]
+    fn test_bolt12_invoice_roundtrip() {
+        // Test data - a real BOLT12 invoice string from submarine.rs tests
+        let invoice_str = "lni1qqgwwn892vxqk9fsgul2fgzxyj5wk93pqtqft5rf2w8ed0c5chus7mqg2x7lx49qajrq8x3yhuu2w0msttwzc5srqxr2q4qqtqss80rn9yedw8hsef9w2lwa83zsfxglnhaen4kl272wrv4uccukswxm5zvq9sy46p548rukhu2vt7g0dsy9r00n2jswepsrngjt7w988ac94hpvqws6qvd2q863an980srs7dpnt6qpqzlxrdkds6l8zz33enxmr42ujqgzfyq6zkdznkzf5m4u7ran24078mtlcdnaltufm4znls5gkq9lyhvqqvhwq0uy4rzc77s7d8gfx4hxemjql7gfcd7l97c3m76vtqnqmkg3eafm2msn4jj864haz42dc6r8r47gt64zrsqqqqqqqqqqqqqqzgqqqqqqqqqqqqqayjedltzjqqqqqq9yq35mrksp4qst37he8z5zvgq948434andxfzlfru53mfvvaycmed6ynt67qyg3xa2qvqcdg9wqvpqqq9syypvp9wsd9fcl94lznzljrmvppgmmu655rkgvqu6yjln3felwpddct8sgrt30e0uynvhy5ydaktehuwctyzkd05wgw4zqn0ayx4d9yndcfhd4ygpjceygz9629n4qm0zn7xa5k8e8xaphu280n4v2y3dzc2etywv";
+
+        // Parse the invoice string
+        let parsed = crate::parse_bolt12_invoice(invoice_str).unwrap();
+
+        // Convert back to string
+        let displayed = crate::display_bolt12_invoice(&parsed);
+
+        // Verify roundtrip - should get back the same string
+        assert_eq!(invoice_str, displayed);
+    }
 }
diff --git a/lwk_boltz/src/prepare_pay_data.rs b/lwk_boltz/src/prepare_pay_data.rs
@@ -4,6 +4,7 @@ use bip39::Mnemonic;
 use boltz_client::boltz::CreateSubmarineResponse;
 use boltz_client::{Bolt11Invoice, Keypair};
 use lightning::bitcoin::XKeyIdentifier;
+use lightning::offers::invoice::Bolt12Invoice;
 use serde::{Deserialize, Serialize};
 
 use crate::error::Error;
@@ -22,6 +23,8 @@ pub struct PreparePayData {
     pub fee: Option<u64>,
     pub boltz_fee: Option<u64>,
     pub bolt11_invoice: Option<Bolt11Invoice>,
+    pub bolt12_invoice: Option<Bolt12Invoice>,
+
     pub create_swap_response: CreateSubmarineResponse,
     pub our_keys: Keypair,
     pub refund_address: String,
@@ -38,6 +41,7 @@ pub struct PreparePayDataSerializable {
     pub fee: Option<u64>,
     pub boltz_fee: Option<u64>,
     pub bolt11_invoice: Option<String>,
+    pub bolt12_invoice: Option<String>,
     pub create_swap_response: CreateSubmarineResponse,
     pub key_index: u32,
     pub refund_address: String,
@@ -55,6 +59,9 @@ impl From<PreparePayData> for PreparePayDataSerializable {
             refund_txid: data.refund_txid,
             fee: data.fee,
             bolt11_invoice: data.bolt11_invoice.map(|i| i.to_string()),
+            bolt12_invoice: data
+                .bolt12_invoice
+                .map(|i| crate::display_bolt12_invoice(&i)),
             create_swap_response: data.create_swap_response,
             key_index: data.key_index,
             refund_address: data.refund_address,
@@ -81,13 +88,19 @@ pub fn to_prepare_pay_data(
         .as_ref()
         .map(|i| Bolt11Invoice::from_str(i))
         .transpose()?;
+    let bolt12_invoice = data
+        .bolt12_invoice
+        .as_ref()
+        .map(|i| crate::parse_bolt12_invoice(i))
+        .transpose()?;
     Ok(PreparePayData {
         last_state: data.last_state,
         swap_type: data.swap_type,
         lockup_txid: data.lockup_txid,
         refund_txid: data.refund_txid,
         fee: data.fee,
         bolt11_invoice,
+        bolt12_invoice,
         create_swap_response: data.create_swap_response,
         our_keys,
         refund_address: data.refund_address,
diff --git a/lwk_boltz/src/submarine.rs b/lwk_boltz/src/submarine.rs
@@ -21,12 +21,12 @@ use lwk_wollet::elements;
 use crate::error::Error;
 use crate::prepare_pay_data::{to_prepare_pay_data, PreparePayData, PreparePayDataSerializable};
 use crate::swap_state::SwapStateTrait;
-use crate::DynStore;
 use crate::SwapPersistence;
 use crate::{
     broadcast_tx_with_retry, mnemonic_identifier, next_status, BoltzSession, LightningPayment,
     SwapState, SwapType,
 };
+use crate::{display_bolt12_invoice, DynStore};
 
 pub struct PreparePayResponse {
     pub data: PreparePayData,
@@ -75,14 +75,27 @@ impl BoltzSession {
     ) -> Result<PreparePayResponse, Error> {
         let chain = self.chain();
 
-        let (bolt11_invoice_str, bolt11_invoice) = match lightning_payment {
-            LightningPayment::Bolt11(invoice) => (invoice.to_string(), invoice),
+        let (invoice_str, bolt11_invoice, bolt12_invoice) = match lightning_payment {
+            LightningPayment::Bolt11(invoice) => {
+                (invoice.to_string(), Some(invoice.as_ref().clone()), None)
+            }
             LightningPayment::Bolt12 {
-                offer: _,
-                invoice_amount: _,
+                offer,
+                invoice_amount,
             } => {
-                // TODO check if the amount is in the offer or in the amount, if there is in both or in neither error (add an error variant)
-                return Err(Error::Bolt12Unsupported);
+                match invoice_amount {
+                    Some(invoice_amount) => {
+                        log::info!("Preparing to pay {invoice_amount}");
+                        let bolt12_invoice =
+                            self.fetch_bolt12_invoice(offer, *invoice_amount).await?;
+                        (
+                            display_bolt12_invoice(&bolt12_invoice),
+                            None,
+                            Some(bolt12_invoice),
+                        )
+                    }
+                    None => return Err(Error::Generic("Amount is required".to_string())), // TODO use appropriate variant
+                }
             }
             LightningPayment::LnUrl(_) => {
                 return Err(Error::LnUrlUnsupported);
@@ -96,26 +109,29 @@ impl BoltzSession {
             compressed: true,
         };
 
-        if let Some((address, amount)) =
-            check_for_mrh(&self.api, &bolt11_invoice_str, chain).await?
-        {
-            let asset_id = self.network().policy_asset().to_string();
-            let mrh_uri = format!(
-                "liquidnetwork:{address}?amount={}&assetid={}",
-                amount.to_string_in(Denomination::Bitcoin),
-                asset_id
-            );
-            return Err(Error::MagicRoutingHint {
-                address: address.to_string(),
-                amount: amount.to_sat(),
-                uri: mrh_uri,
-            });
+        if bolt11_invoice.is_some() {
+            // mrh works only with bolt11
+
+            if let Some((address, amount)) = check_for_mrh(&self.api, &invoice_str, chain).await? {
+                let asset_id = self.network().policy_asset().to_string();
+                let mrh_uri = format!(
+                    "liquidnetwork:{address}?amount={}&assetid={}",
+                    amount.to_string_in(Denomination::Bitcoin),
+                    asset_id
+                );
+                return Err(Error::MagicRoutingHint {
+                    address: address.to_string(),
+                    amount: amount.to_sat(),
+                    uri: mrh_uri,
+                });
+            }
         }
+        log::error!("no mrh");
 
         let create_swap_req = CreateSubmarineRequest {
             from: chain.to_string(),
             to: "BTC".to_string(),
-            invoice: bolt11_invoice_str.clone(),
+            invoice: invoice_str.clone(),
             refund_public_key,
             pair_hash: None,
             referral_id: self.referral_id.clone(),
@@ -127,16 +143,22 @@ impl BoltzSession {
             "accept zero conf: {}",
             create_swap_response.accept_zero_conf
         );
-        let bolt11_amount = bolt11_invoice
-            .amount_milli_satoshis()
-            .ok_or(Error::InvoiceWithoutAmount(bolt11_invoice_str.clone()))?
-            / 1000;
+        let bolt11_amount = match (bolt11_invoice.as_ref(), bolt12_invoice.as_ref()) {
+            (Some(bolt11_invoice), None) => {
+                bolt11_invoice
+                    .amount_milli_satoshis()
+                    .ok_or(Error::InvoiceWithoutAmount(invoice_str.clone()))?
+                    / 1000
+            }
+            (None, Some(bolt12_invoice)) => bolt12_invoice.amount_msats() / 1000,
+            _ => unreachable!(),
+        };
         let fee = create_swap_response
             .expected_amount
             .checked_sub(bolt11_amount)
             .ok_or(Error::ExpectedAmountLowerThanInvoice(
                 create_swap_response.expected_amount,
-                bolt11_invoice_str.clone(),
+                invoice_str.clone(),
             ))?;
 
         let boltz_fee = self
@@ -149,8 +171,11 @@ impl BoltzSession {
 
         log::info!("Got Swap Response from Boltz server {create_swap_response:?}");
 
-        create_swap_response.validate(&bolt11_invoice_str, &refund_public_key, chain)?;
-        log::info!("VALIDATED RESPONSE!");
+        if bolt11_invoice.is_some() {
+            // TODO: boltz-rust dep doesn't support bolt12 yet
+            create_swap_response.validate(&invoice_str, &refund_public_key, chain)?;
+            log::info!("VALIDATED RESPONSE!");
+        }
 
         let swap_script =
             SwapScript::submarine_from_swap_resp(chain, &create_swap_response, refund_public_key)?;
@@ -188,7 +213,8 @@ impl BoltzSession {
                 refund_txid: None,
                 fee: Some(fee),
                 boltz_fee,
-                bolt11_invoice: Some((**bolt11_invoice).clone()),
+                bolt11_invoice,
+                bolt12_invoice,
                 our_keys,
                 refund_address: refund_address.to_string(),
                 create_swap_response: create_swap_response.clone(),
@@ -361,6 +387,7 @@ pub(crate) fn convert_swap_restore_response_to_prepare_pay_data(
         refund_txid: None,
         fee: None,            // Fee information not available in restore response
         bolt11_invoice: None, // Invoice information not available in restore response
+        bolt12_invoice: None, // Invoice information not available in restore response
         our_keys,
         refund_address: refund_address.to_string(),
         create_swap_response,
diff --git a/lwk_boltz/tests/submarine.rs b/lwk_boltz/tests/submarine.rs
@@ -54,7 +54,80 @@ mod tests {
 
     #[tokio::test]
     #[ignore = "requires regtest environment"]
-    async fn test_bolt12_offer_to_bolt11_and_pay_with_session() {
+    async fn test_bolt12_pay_with_session() {
+        let _ = env_logger::try_init();
+
+        // Start concurrent block mining task
+        let mining_handle = utils::start_block_mining();
+
+        // Ask CLN for a BOLT12 offer
+        let offer_str = utils::cln_offer_any().expect("cln_offer_any should succeed");
+
+        let mut payment: LightningPayment = offer_str.parse().unwrap();
+        assert!(payment.bolt12().is_some());
+        assert!(payment.bolt12_invoice_amount().unwrap().is_none());
+
+        // create a BoltzSession
+        let client = Arc::new(
+            ElectrumClient::new(
+                DEFAULT_REGTEST_NODE,
+                false,
+                false,
+                ElementsNetwork::default_regtest(),
+            )
+            .unwrap(),
+        );
+        let session = BoltzSession::builder(
+            ElementsNetwork::default_regtest(),
+            AnyClient::Electrum(client.clone()),
+        )
+        .build()
+        .await
+        .unwrap();
+
+        // Try to pay the bolt12
+        let refund_address = utils::generate_address(Chain::Liquid(LiquidChain::LiquidRegtest))
+            .await
+            .unwrap();
+        let refund_address = elements::Address::from_str(&refund_address).unwrap();
+        let prepare_pay_err = session
+            .prepare_pay(&payment, &refund_address, None)
+            .await
+            .unwrap_err()
+            .to_string();
+        assert!(prepare_pay_err.contains("Amount is required"));
+
+        let millisat_amount = 10_000_000;
+        payment.set_bolt12_invoice_amount(millisat_amount).unwrap();
+        assert_eq!(
+            payment.bolt12_invoice_amount().unwrap().unwrap(),
+            millisat_amount
+        );
+
+        let prepare_pay = session
+            .prepare_pay(&payment, &refund_address, None)
+            .await
+            .unwrap();
+
+        // Send funds to the swap address
+        utils::send_to_address(
+            Chain::Liquid(LiquidChain::LiquidRegtest),
+            &prepare_pay.data.create_swap_response.address,
+            prepare_pay.data.create_swap_response.expected_amount,
+        )
+        .await
+        .unwrap();
+
+        // Complete the payment
+        prepare_pay.complete_pay().await.unwrap();
+
+        // Stop the mining task
+        mining_handle.abort();
+    }
+
+    #[tokio::test]
+    #[ignore = "requires regtest environment"]
+    async fn test_bolt12_offer_to_invoice_and_pay_with_session() {
         let _ = env_logger::try_init();
 
         // Ask CLN for a BOLT12 offer
@@ -90,52 +163,6 @@ mod tests {
         assert!(!verify_invoice_from_offer(&another_bolt12_invoice, &offer));
     }
 
-    #[tokio::test]
-    #[ignore = "requires regtest environment"]
-    async fn test_bolt12_offer_returns_unsupported_error() {
-        let _ = env_logger::try_init();
-
-        // Get a BOLT12 offer from CLN
-        let offer_str = utils::cln_offer_any().expect("cln_offer_any should succeed");
-        let lightning_payment = LightningPayment::from_str(&offer_str).unwrap();
-
-        // Set up BoltzSession
-        let refund_address = utils::generate_address(Chain::Liquid(LiquidChain::LiquidRegtest))
-            .await
-            .unwrap();
-        let refund_address = elements::Address::from_str(&refund_address).unwrap();
-        let client = Arc::new(
-            ElectrumClient::new(
-                DEFAULT_REGTEST_NODE,
-                false,
-                false,
-                ElementsNetwork::default_regtest(),
-            )
-            .unwrap(),
-        );
-
-        let session = BoltzSession::builder(
-            ElementsNetwork::default_regtest(),
-            AnyClient::Electrum(client.clone()),
-        )
-        .create_swap_timeout(TIMEOUT)
-        .build()
-        .await
-        .unwrap();
-
-        // Try to pay the bolt12 offer and expect Bolt12Unsupported error
-        let result = session
-            .prepare_pay(&lightning_payment, &refund_address, None)
-            .await;
-
-        match result {
-            Err(lwk_boltz::Error::Bolt12Unsupported) => {
-                // Expected error
-            }
-            _ => panic!("Expected Bolt12Unsupported error, got: {:?}", result),
-        }
-    }
-
     #[tokio::test]
     #[ignore = "requires regtest environment"]
     async fn test_session_submarine_base() {
