refactor: move pay offer with name to a separate endpoint

Extract BIP-353 human-readable name payment into dedicated PayName
RPC endpoint, separate from PayOffer. This improves API clarity by
distinguishing direct offer payments from name-based payments that
require DNS resolution.

Author: IgnacioPorte

proto/lndkrpc.proto

@@ -5,6 +5,7 @@ import "external/google/rpc/error_details.proto";
 
 service Offers {
     rpc PayOffer (PayOfferRequest) returns (PayOfferResponse);
+    rpc PayName (PayNameRequest) returns (PayOfferResponse);
     rpc GetInvoice (GetInvoiceRequest) returns (GetInvoiceResponse);
     rpc DecodeInvoice (DecodeInvoiceRequest) returns (Bolt12InvoiceContents);
     rpc PayInvoice (PayInvoiceRequest) returns (PayInvoiceResponse);
@@ -18,7 +19,15 @@ message PayOfferRequest {
    optional uint32 response_invoice_timeout = 4;
    optional uint32 fee_limit = 5;
    optional uint32 fee_limit_percent = 6;
-   optional string name  = 7; 
+}
+
+message PayNameRequest {
+   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 {

src/cli.rs

@@ -1,7 +1,9 @@
 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, PayInvoiceRequest, PayNameRequest, PayOfferRequest,
+};
 use lndk::offers::decode;
 use lndk::offers::handler::DEFAULT_RESPONSE_INVOICE_TIMEOUT;
 use lndk::{
@@ -143,10 +145,34 @@ enum Commands {
         /// Mutually exclusive with fee_limit - only one can be set.
         #[arg(long, required = false, conflicts_with = "fee_limit")]
         fee_limit_percent: Option<u32>,
+    },
+    /// PayName pays a BOLT 12 offer by resolving a human-readable name (BIP-353).
+    PayName {
+        /// The human-readable name to resolve (e.g., "user@example.com").
+        name: String,
 
-        /// The human readable name of the user to pay.
+        /// 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)]
-        name: Option<String>,
+        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.
@@ -235,7 +261,6 @@ async fn main() {
             response_invoice_timeout,
             fee_limit,
             fee_limit_percent,
-            name,
         } => {
             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;
@@ -258,7 +283,6 @@ async fn main() {
                 response_invoice_timeout,
                 fee_limit,
                 fee_limit_percent,
-                name,
             });
             add_metadata(&mut request, macaroon);
 
@@ -267,6 +291,38 @@ async fn main() {
                 Err(err) => err.exit_gracefully(),
             };
         }
+        Commands::PayName {
+            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(PayNameRequest {
+                name: name.clone(),
+                amount,
+                payer_note,
+                response_invoice_timeout,
+                fee_limit,
+                fee_limit_percent,
+            });
+            add_metadata(&mut request, macaroon);
+
+            match client.pay_name(request).await {
+                Ok(_) => println!("Successfully paid for name {}!", name),
+                Err(err) => err.exit_gracefully(),
+            };
+        }
         Commands::GetInvoice {
             ref offer_string,
             amount,

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 PayNameParams {
+    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_name(&self, cfg: PayNameParams) -> Result<Payment, OfferError> {
+        let offer_str = LndkDNSResolverMessageHandler::new()
+            .resolve_name_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/server.rs

@@ -1,8 +1,7 @@
-use crate::dns_resolver::LndkDNSResolverMessageHandler;
 use crate::lnd::{get_lnd_client, get_network, Creds, LndCfg, LndError};
 use crate::lndkrpc::{CreateOfferRequest, CreateOfferResponse};
 use crate::offers::get_destination;
-use crate::offers::handler::{CreateOfferParams, PayOfferParams};
+use crate::offers::handler::{CreateOfferParams, PayNameParams, PayOfferParams};
 use crate::offers::parse::decode;
 use crate::offers::validate_amount;
 use crate::offers::OfferError;
@@ -18,8 +17,8 @@ use lightning::util::ser::Writeable;
 use lndkrpc::offers_server::Offers;
 use lndkrpc::{
     Bolt12InvoiceContents, DecodeInvoiceRequest, FeatureBit, GetInvoiceRequest, GetInvoiceResponse,
-    PayInvoiceRequest, PayInvoiceResponse, PayOfferRequest, PayOfferResponse, PaymentHash,
-    PaymentPaths,
+    PayInvoiceRequest, PayInvoiceResponse, PayNameRequest, PayOfferRequest, PayOfferResponse,
+    PaymentHash, PaymentPaths,
 };
 use std::num::NonZeroU64;
 use std::str::FromStr;
@@ -73,20 +72,7 @@ impl Offers for LNDKServer {
         let mut client = get_lnd_client(lnd_cfg)?;
 
         let inner_request = request.get_ref();
-
-        let offer_str = if let Some(name_str) = &inner_request.name {
-            if !name_str.is_empty() {
-                LndkDNSResolverMessageHandler::new()
-                    .resolve_name_to_offer(name_str)
-                    .await?
-            } else {
-                inner_request.offer.clone()
-            }
-        } else {
-            inner_request.offer.clone()
-        };
-
-        let offer = decode(offer_str)?;
+        let offer = decode(inner_request.offer.clone())?;
 
         let destination = get_destination(&offer).await?;
         let reply_path = None;
@@ -125,6 +111,57 @@ impl Offers for LNDKServer {
         Ok(Response::new(reply))
     }
 
+    async fn pay_name(
+        &self,
+        request: Request<PayNameRequest>,
+    ) -> Result<Response<PayOfferResponse>, Status> {
+        log::info!("Received a request: {:?}", request.get_ref());
+
+        let metadata = request.metadata();
+        let macaroon = check_auth_metadata(metadata)?;
+        let creds = Creds::String {
+            cert: self.lnd_cert.clone(),
+            macaroon,
+        };
+        let lnd_cfg = LndCfg::new(self.address.clone(), creds);
+        let mut client = get_lnd_client(lnd_cfg)?;
+
+        let inner_request = request.get_ref();
+        let reply_path = None;
+        let info = client
+            .lightning()
+            .get_info(GetInfoRequest {})
+            .await
+            .map_err(|e| LndError::ServiceUnavailable(e.message().to_string()))?
+            .into_inner();
+        let network = get_network(info).await?;
+
+        let fee_limit = create_fee_limit(inner_request.fee_limit, inner_request.fee_limit_percent);
+
+        let cfg = PayNameParams {
+            name: inner_request.name.clone(),
+            amount: inner_request.amount,
+            payer_note: inner_request.payer_note.clone(),
+            network,
+            client,
+            reply_path,
+            response_invoice_timeout: inner_request.response_invoice_timeout,
+            fee_limit,
+        };
+
+        let payment = self.offer_handler.pay_name(cfg).await?;
+        log::info!(
+            "Payment succeeded with preimage: {}",
+            payment.payment_preimage
+        );
+
+        let reply = PayOfferResponse {
+            payment_preimage: payment.payment_preimage,
+        };
+
+        Ok(Response::new(reply))
+    }
+
     async fn decode_invoice(
         &self,
         request: Request<DecodeInvoiceRequest>,