test: add BIP-353 integration test for pay_offer with name resolution

Add integration test validating end-to-end payment using human-readable names.
Uses mock DNS resolver to test server-side name resolution and payment flow.

Author: IgnacioPorte

src/dns_resolver.rs

@@ -3,6 +3,12 @@ use bitcoin_payment_instructions::hrn_resolution::{HrnResolution, HrnResolver, H
 use bitcoin_payment_instructions::http_resolver::HTTPHrnResolver;
 use std::sync::Arc;
 
+#[cfg(itest)]
+use std::sync::RwLock;
+
+#[cfg(itest)]
+pub static TEST_RESOLVER: RwLock<Option<Arc<dyn HrnResolver + Send + Sync>>> = RwLock::new(None);
+
 pub struct LndkDNSResolverMessageHandler {
     resolver: Arc<dyn HrnResolver + Send + Sync>,
 }
@@ -15,6 +21,16 @@ impl Default for LndkDNSResolverMessageHandler {
 
 impl LndkDNSResolverMessageHandler {
     pub fn new() -> Self {
+        #[cfg(itest)]
+        {
+            if let Ok(guard) = TEST_RESOLVER.read() {
+                if let Some(test_resolver) = guard.as_ref() {
+                    return Self {
+                        resolver: Arc::clone(test_resolver),
+                    };
+                }
+            }
+        }
         Self::with_resolver(HTTPHrnResolver::new())
     }
 

tests/integration_tests.rs

@@ -27,9 +27,9 @@ use std::net::SocketAddr;
 use std::path::PathBuf;
 use std::str::FromStr;
 use std::sync::Arc;
-use std::time::SystemTime;
+use std::time::{Duration, SystemTime};
 use tokio::time;
-use tokio::time::Duration;
+
 use tokio::{select, try_join};
 use tonic_lnd::Client;
 
@@ -1440,3 +1440,228 @@ async fn test_receive_payment_from_offer_with_multiple_blinded_paths() {
         }
     };
 }
+
+struct MockHrnResolver {
+    response_uri: String,
+}
+
+fn set_test_dns_resolver<
+    R: bitcoin_payment_instructions::hrn_resolution::HrnResolver + Send + Sync + 'static,
+>(
+    resolver: R,
+) {
+    if let Ok(mut guard) = lndk::dns_resolver::TEST_RESOLVER.write() {
+        *guard = Some(std::sync::Arc::new(resolver));
+    }
+}
+
+fn clear_test_dns_resolver() {
+    if let Ok(mut guard) = lndk::dns_resolver::TEST_RESOLVER.write() {
+        *guard = None;
+    }
+}
+
+impl bitcoin_payment_instructions::hrn_resolution::HrnResolver for MockHrnResolver {
+    fn resolve_hrn<'a>(
+        &'a self,
+        _hrn: &'a bitcoin_payment_instructions::hrn_resolution::HumanReadableName,
+    ) -> bitcoin_payment_instructions::hrn_resolution::HrnResolutionFuture<'a> {
+        let uri = self.response_uri.clone();
+        Box::pin(async move {
+            Ok(
+                bitcoin_payment_instructions::hrn_resolution::HrnResolution::DNSSEC {
+                    proof: None,
+                    result: uri,
+                },
+            )
+        })
+    }
+
+    fn resolve_lnurl<'a>(
+        &'a self,
+        _url: &'a str,
+    ) -> bitcoin_payment_instructions::hrn_resolution::HrnResolutionFuture<'a> {
+        Box::pin(async { Err("LNURL resolution not supported in mock") })
+    }
+
+    fn resolve_lnurl_to_invoice<'a>(
+        &'a self,
+        _callback_url: String,
+        _amount: bitcoin_payment_instructions::amount::Amount,
+        _expected_description_hash: [u8; 32],
+    ) -> bitcoin_payment_instructions::hrn_resolution::LNURLResolutionFuture<'a> {
+        Box::pin(async { Err("LNURL invoice resolution not supported in mock") })
+    }
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_pay_offer_with_name_and_dns() {
+    use lndk::lndkrpc::offers_client::OffersClient;
+    use lndk::lndkrpc::offers_server::OffersServer;
+    use lndk::lndkrpc::PayOfferRequest;
+    use std::time::{Duration, SystemTime};
+    use tonic::transport::{Identity, Server, ServerTlsConfig};
+
+    let test_name = "lndk_pay_offer_with_name";
+    let (bitcoind, mut lnd, ldk1, ldk2, lndk_dir, _) =
+        common::setup_test_infrastructure(test_name).await;
+
+    let (ldk1_pubkey, ldk2_pubkey, _) =
+        common::connect_network(&ldk1, &ldk2, false, true, &mut lnd, &bitcoind).await;
+
+    let path_pubkeys = vec![ldk2_pubkey, ldk1_pubkey];
+    let expiration = SystemTime::now() + Duration::from_secs(24 * 60 * 60);
+    let offer = ldk1
+        .create_offer(
+            &path_pubkeys,
+            Network::Regtest,
+            20_000,
+            Quantity::One,
+            expiration,
+        )
+        .await
+        .expect("should create offer");
+
+    let offer_string = offer.to_string();
+    let human_readable_name = "satoshi@bip353.test";
+
+    let mock_resolver = MockHrnResolver {
+        response_uri: format!("bitcoin:?lno={}", offer_string),
+    };
+
+    set_test_dns_resolver(mock_resolver);
+
+    let dns_resolver = lndk::dns_resolver::LndkDNSResolverMessageHandler::new();
+    let resolved_offer = dns_resolver
+        .resolve_name_to_offer(human_readable_name)
+        .await;
+    assert!(
+        resolved_offer.is_ok(),
+        "DNS resolution failed: {:?}",
+        resolved_offer.err()
+    );
+    assert_eq!(resolved_offer.unwrap(), offer_string);
+
+    let (lndk_cfg, handler, messenger, shutdown) = common::setup_lndk(
+        &lnd.cert_path,
+        &lnd.macaroon_path,
+        lnd.address.clone(),
+        lndk_dir.clone(),
+    )
+    .await;
+
+    let mut lnd_client = lnd.client.clone().unwrap();
+    let info = lnd_client
+        .lightning()
+        .get_info(tonic_lnd::lnrpc::GetInfoRequest {})
+        .await
+        .expect("failed to get info")
+        .into_inner();
+
+    let server_addr = format!(
+        "{}:{}",
+        lndk::DEFAULT_SERVER_HOST,
+        lndk::DEFAULT_SERVER_PORT
+    );
+    let server_socket_addr: SocketAddr = server_addr.parse().unwrap();
+
+    let lnd_cert_path = PathBuf::from(&lnd.cert_path);
+    let lnd_cert = std::fs::read_to_string(lnd_cert_path).unwrap();
+
+    let lndk_server = lndk::server::LNDKServer::new(
+        handler.clone(),
+        &info.identity_pubkey,
+        lnd_cert.clone(),
+        lnd.address.clone(),
+    )
+    .await;
+
+    let tls_cert_path = lndk_dir.join(lndk::TLS_CERT_FILENAME);
+    let tls_key_path = lndk_dir.join(lndk::TLS_KEY_FILENAME);
+
+    if !tls_cert_path.exists() || !tls_key_path.exists() {
+        use rcgen::generate_simple_self_signed;
+        let cert_key = generate_simple_self_signed(vec!["localhost".to_string()])
+            .expect("failed to generate certificate");
+        std::fs::write(
+            &tls_key_path,
+            cert_key.signing_key.serialize_pem().as_bytes(),
+        )
+        .expect("failed to write key");
+        std::fs::write(&tls_cert_path, cert_key.cert.pem()).expect("failed to write cert");
+    }
+
+    let tls_cert = std::fs::read_to_string(tls_cert_path.clone()).unwrap();
+    let tls_key = std::fs::read_to_string(tls_key_path).unwrap();
+    let identity = Identity::from_pem(tls_cert.clone(), tls_key);
+
+    let (server_shutdown, server_listener) = triggered::trigger();
+    let server_handle = tokio::spawn(async move {
+        Server::builder()
+            .tls_config(ServerTlsConfig::new().identity(identity))
+            .expect("couldn't configure tls")
+            .add_service(OffersServer::new(lndk_server))
+            .serve_with_shutdown(server_socket_addr, server_listener)
+            .await
+    });
+
+    tokio::time::sleep(Duration::from_secs(1)).await;
+
+    select! {
+        val = messenger.run(lndk_cfg, Arc::clone(&handler)) => {
+            panic!("messenger should not complete first {:?}", val);
+        },
+        result = async {
+            let lndk_cert_pem = std::fs::read_to_string(tls_cert_path).unwrap();
+            let macaroon_bytes = std::fs::read(&lnd.macaroon_path).unwrap();
+            let macaroon_hex = hex::encode(macaroon_bytes);
+
+            let cert = tonic::transport::Certificate::from_pem(lndk_cert_pem.as_bytes());
+            let tls_config = tonic::transport::ClientTlsConfig::new()
+                .ca_certificate(cert)
+                .domain_name("localhost");
+
+            let channel = tonic::transport::Channel::from_shared(format!("https://{}", server_addr))
+                .unwrap()
+                .tls_config(tls_config)
+                .unwrap()
+                .connect()
+                .await
+                .expect("failed to connect to lndk server");
+
+            let mut client = OffersClient::new(channel);
+
+            let mut request = tonic::Request::new(PayOfferRequest {
+                offer: String::new(),
+                amount: Some(20_000),
+                payer_note: None,
+                response_invoice_timeout: None,
+                fee_limit: None,
+                fee_limit_percent: None,
+                name: Some(human_readable_name.to_string()),
+            });
+
+            request.metadata_mut().insert(
+                "macaroon",
+                macaroon_hex.parse().expect("failed to parse macaroon"),
+            );
+
+            let result = client.pay_offer(request).await;
+            assert!(result.is_ok(), "pay_offer failed: {:?}", result.err());
+
+            let response = result.as_ref().unwrap().get_ref();
+            assert!(!response.payment_preimage.is_empty(), "Payment should have a preimage");
+            result
+        } => {
+            assert!(result.is_ok());
+
+            server_shutdown.trigger();
+            shutdown.trigger();
+            let _ = tokio::time::timeout(Duration::from_secs(5), server_handle).await;
+            ldk1.stop().await;
+            ldk2.stop().await;
+
+            clear_test_dns_resolver();
+        }
+    }
+}