Implementation of bip-0353

Cargo.toml

@@ -43,6 +43,8 @@ bytes = "1.4.0"
 triggered = "0.1.2"
 prost = "0.14.1"
 async_fn_traits = "0.1.1"
+bitcoin-payment-instructions = { version = "0.5", features = ["http"] }
+reqwest = { version = "0.11", default-features = false, features = ["rustls-tls"] }
 
 # Integration test dependencies, only enabled with itest feature
 bitcoincore-rpc = { version = "0.19.0", optional = true }

proto/lndkrpc.proto

@@ -5,6 +5,7 @@ import "external/google/rpc/error_details.proto";
 
 service Offers {
     rpc PayOffer (PayOfferRequest) returns (PayOfferResponse);
+    rpc PayHumanReadableAddress (PayHumanReadableAddressRequest) returns (PayOfferResponse);
     rpc GetInvoice (GetInvoiceRequest) returns (GetInvoiceResponse);
     rpc DecodeInvoice (DecodeInvoiceRequest) returns (Bolt12InvoiceContents);
     rpc PayInvoice (PayInvoiceRequest) returns (PayInvoiceResponse);
@@ -20,6 +21,15 @@ message PayOfferRequest {
    optional uint32 fee_limit_percent = 6;
 }
 
+message PayHumanReadableAddressRequest {
+   string name = 1;
+   optional uint64 amount = 2;
+   optional string payer_note = 3;
+   optional uint32 response_invoice_timeout = 4;
+   optional uint32 fee_limit = 5;
+   optional uint32 fee_limit_percent = 6;
+}
+
 message PayOfferResponse {
     string payment_preimage = 2;
 }

src/cli.rs

@@ -1,7 +1,10 @@
 use clap::{Parser, Subcommand};
 use lightning::offers::invoice::Bolt12Invoice;
 use lndk::lndkrpc::offers_client::OffersClient;
-use lndk::lndkrpc::{CreateOfferRequest, GetInvoiceRequest, PayInvoiceRequest, PayOfferRequest};
+use lndk::lndkrpc::{
+    CreateOfferRequest, GetInvoiceRequest, PayHumanReadableAddressRequest, PayInvoiceRequest,
+    PayOfferRequest,
+};
 use lndk::offers::decode;
 use lndk::offers::handler::DEFAULT_RESPONSE_INVOICE_TIMEOUT;
 use lndk::{
@@ -144,6 +147,34 @@ enum Commands {
         #[arg(long, required = false, conflicts_with = "fee_limit")]
         fee_limit_percent: Option<u32>,
     },
+    /// PayHumanReadableAddress pays a BOLT 12 offer by resolving a human-readable name (BIP-353).
+    PayHumanReadableAddress {
+        /// The human-readable name to resolve (e.g., "user@example.com").
+        name: String,
+
+        /// Amount the user would like to pay. If this isn't set, we'll assume the user is paying
+        /// whatever the offer amount is.
+        #[arg(required = false)]
+        amount: Option<u64>,
+
+        /// A payer-provided note which will be seen by the recipient.
+        #[arg(required = false)]
+        payer_note: Option<String>,
+
+        /// The amount of time in seconds that the user would like to wait for an invoice to
+        /// arrive. If this isn't set, we'll use the default value.
+        #[arg(long, global = false, required = false, default_value = DEFAULT_RESPONSE_INVOICE_TIMEOUT.to_string())]
+        response_invoice_timeout: Option<u32>,
+
+        /// A fixed fee limit in millisatoshis.
+        /// Mutually exclusive with fee_limit_percent - only one can be set.
+        #[arg(long, required = false, conflicts_with = "fee_limit_percent")]
+        fee_limit: Option<u32>,
+        /// A percentage-based fee limit of the payment amount.
+        /// Mutually exclusive with fee_limit - only one can be set.
+        #[arg(long, required = false, conflicts_with = "fee_limit")]
+        fee_limit_percent: Option<u32>,
+    },
     /// GetInvoice fetch a BOLT 12 invoice, which will be returned as a hex-encoded string. It
     /// fetches the invoice from a BOLT 12 offer, provided as a 'lno'-prefaced offer string.
     GetInvoice {
@@ -261,6 +292,38 @@ async fn main() {
                 Err(err) => err.exit_gracefully(),
             };
         }
+        Commands::PayHumanReadableAddress {
+            ref name,
+            amount,
+            payer_note,
+            response_invoice_timeout,
+            fee_limit,
+            fee_limit_percent,
+        } => {
+            let tls = read_cert_from_args_or_exit(args.cert_pem, args.cert_path);
+            let channel = create_grpc_channel(args.grpc_host, args.grpc_port, tls).await;
+            let (mut client, macaroon) = create_authenticated_client(
+                channel,
+                args.macaroon_path,
+                args.macaroon_hex,
+                &args.network,
+            );
+
+            let mut request = Request::new(PayHumanReadableAddressRequest {
+                name: name.clone(),
+                amount,
+                payer_note,
+                response_invoice_timeout,
+                fee_limit,
+                fee_limit_percent,
+            });
+            add_metadata(&mut request, macaroon);
+
+            match client.pay_human_readable_address(request).await {
+                Ok(_) => println!("Successfully paid for name {}!", name),
+                Err(err) => err.exit_gracefully(),
+            };
+        }
         Commands::GetInvoice {
             ref offer_string,
             amount,

src/dns_resolver.rs

@@ -0,0 +1,89 @@
+use crate::OfferError;
+use bitcoin_payment_instructions::hrn_resolution::{HrnResolution, HrnResolver, HumanReadableName};
+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>,
+}
+
+impl Default for LndkDNSResolverMessageHandler {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+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())
+    }
+
+    pub fn with_resolver<R: HrnResolver + Send + Sync + 'static>(resolver: R) -> Self {
+        Self {
+            resolver: Arc::new(resolver),
+        }
+    }
+
+    pub async fn resolver_hrn_to_offer(&self, name_str: &str) -> Result<String, OfferError> {
+        let resolved_uri = self.resolve_locally(name_str.to_string()).await?;
+        self.extract_offer_from_uri(&resolved_uri)
+    }
+
+    pub fn extract_offer_from_uri(&self, uri: &str) -> Result<String, OfferError> {
+        if let Some((_scheme, params)) = uri.split_once("?") {
+            for param in params.split("&") {
+                if let Some((key, value)) = param.split_once("=") {
+                    if key.eq_ignore_ascii_case("lno") {
+                        return Ok(value.to_string());
+                    }
+                }
+            }
+            Err(OfferError::ResolveUriError(
+                "URI does not contain 'lno' parameter with BOLT12 offer".to_string(),
+            ))
+        } else {
+            Err(OfferError::ResolveUriError(format!(
+                "Invalid URI format - expected bitcoin:?lno=<offer>, got: {}",
+                uri
+            )))
+        }
+    }
+
+    pub async fn resolve_locally(&self, name: String) -> Result<String, OfferError> {
+        let hrn_parsed = HumanReadableName::from_encoded(&name)
+            .map_err(|_| OfferError::ParseHrnFailure(name.clone()))?;
+
+        let resolution = self
+            .resolver
+            .resolve_hrn(&hrn_parsed)
+            .await
+            .map_err(|e| OfferError::HrnResolutionFailure(format!("{}: {}", name, e)))?;
+
+        let uri = match resolution {
+            HrnResolution::DNSSEC { result, .. } => result,
+            HrnResolution::LNURLPay { .. } => {
+                return Err(OfferError::ResolveUriError(
+                    "LNURL resolution not supported in this flow".to_string(),
+                ))
+            }
+        };
+
+        Ok(uri)
+    }
+}

src/lib.rs

@@ -1,4 +1,5 @@
 mod clock;
+pub mod dns_resolver;
 mod grpc;
 #[allow(dead_code)]
 pub mod lnd;

src/offers/handler.rs

@@ -31,7 +31,9 @@ use super::lnd_requests::{
     send_invoice_request, LndkBolt12InvoiceInfo,
 };
 use super::OfferError;
+use crate::dns_resolver::LndkDNSResolverMessageHandler;
 use crate::offers::lnd_requests::{send_payment, track_payment, CreateOfferArgs};
+use crate::offers::{get_destination, parse::decode};
 use crate::onion_messenger::MessengerUtilities;
 
 pub const DEFAULT_RESPONSE_INVOICE_TIMEOUT: u32 = 15;
@@ -77,6 +79,18 @@ pub struct PayOfferParams {
     pub fee_limit: Option<FeeLimit>,
 }
 
+#[derive(Clone)]
+pub struct PayHumanReadableAddressParams {
+    pub name: String,
+    pub amount: Option<u64>,
+    pub payer_note: Option<String>,
+    pub network: Network,
+    pub client: Client,
+    pub reply_path: Option<BlindedMessagePath>,
+    pub response_invoice_timeout: Option<u32>,
+    pub fee_limit: Option<FeeLimit>,
+}
+
 #[derive(Clone)]
 pub struct SendPaymentParams {
     pub path: BlindedPaymentPath,
@@ -150,6 +164,30 @@ impl OfferHandler {
         .await
     }
 
+    /// Resolves a human-readable name (BIP-353) to an offer and pays it.
+    pub async fn pay_hrn(&self, cfg: PayHumanReadableAddressParams) -> Result<Payment, OfferError> {
+        let offer_str = LndkDNSResolverMessageHandler::new()
+            .resolver_hrn_to_offer(&cfg.name)
+            .await?;
+
+        let offer = decode(offer_str)?;
+        let destination = get_destination(&offer).await?;
+
+        let pay_offer_cfg = PayOfferParams {
+            offer,
+            amount: cfg.amount,
+            payer_note: cfg.payer_note,
+            network: cfg.network,
+            client: cfg.client,
+            destination,
+            reply_path: cfg.reply_path,
+            response_invoice_timeout: cfg.response_invoice_timeout,
+            fee_limit: cfg.fee_limit,
+        };
+
+        self.pay_offer(pay_offer_cfg).await
+    }
+
     /// Sends an invoice request and waits for an invoice to be sent back to us.
     /// Reminder that if this method returns an error after create_invoice_request is called, we
     /// *must* remove the payment_id from self.active_payments.

src/offers/mod.rs

@@ -71,6 +71,12 @@ pub enum OfferError {
     EncodeInvoiceFailure(BitcoinIoError),
     /// Cannot list channels.
     ListChannelsFailure(String),
+    /// Failed to parse human-readable name.
+    ParseHrnFailure(String),
+    /// HRN resolution failed.
+    HrnResolutionFailure(String),
+    /// DNS resolution or URI parsing error.
+    ResolveUriError(String),
 }
 
 impl OfferError {
@@ -101,6 +107,9 @@ impl OfferError {
             OfferError::IntroductionNodeNotFound => "INTRODUCTION_NODE_NOT_FOUND",
             OfferError::GetChannelInfo(_) => "GET_CHANNEL_INFO",
             OfferError::ListChannelsFailure(_) => "LIST_CHANNELS_FAILURE",
+            OfferError::ParseHrnFailure(_) => "PARSE_HRN_FAILURE",
+            OfferError::HrnResolutionFailure(_) => "HRN_RESOLUTION_FAILURE",
+            OfferError::ResolveUriError(_) => "RESOLVE_URI_ERROR",
         }
     }
 
@@ -110,7 +119,10 @@ impl OfferError {
             | OfferError::InvalidCurrency
             | OfferError::ParseOfferFailure(_)
             | OfferError::ParseInvoiceFailure(_)
-            | OfferError::EncodeInvoiceFailure(_) => Code::InvalidArgument,
+            | OfferError::EncodeInvoiceFailure(_)
+            | OfferError::ParseHrnFailure(_)
+            | OfferError::HrnResolutionFailure(_)
+            | OfferError::ResolveUriError(_) => Code::InvalidArgument,
             _ => Code::Internal,
         }
     }
@@ -168,6 +180,15 @@ impl Display for OfferError {
             }
             OfferError::ListChannelsFailure(e) => write!(f, "Error listing channels: {e:?}"),
             OfferError::EncodeInvoiceFailure(e) => write!(f, "Failed to encode invoice: {e:?}"),
+            OfferError::ParseHrnFailure(e) => {
+                write!(f, "Invalid human-readable name: {}", e)
+            }
+            OfferError::HrnResolutionFailure(e) => {
+                write!(f, "HRN resolution failed: {}", e)
+            }
+            OfferError::ResolveUriError(e) => {
+                write!(f, "Failed to resolve URI: {}", e)
+            }
         }
     }
 }