add max_fee for payments

Author: riccardobl

proto/lndkrpc.proto

@@ -13,6 +13,7 @@ message PayOfferRequest {
    optional uint64 amount = 2;
    optional string payer_note = 3;
    optional uint32 response_invoice_timeout = 4;
+   optional uint64 max_fee = 5;
 }
 
 message PayOfferResponse {
@@ -38,6 +39,7 @@ message GetInvoiceResponse {
 message PayInvoiceRequest {
     string invoice = 1;
     optional uint64 amount = 2;
+    optional uint64 max_fee = 3;
 }
 
 message PayInvoiceResponse {

src/cli.rs

@@ -215,6 +215,7 @@ async fn main() {
                 amount,
                 payer_note,
                 response_invoice_timeout,
+                max_fee: None,
             });
             add_metadata(&mut request, macaroon).unwrap_or_else(|_| exit(1));
 
@@ -314,6 +315,7 @@ async fn main() {
             let mut request = Request::new(PayInvoiceRequest {
                 invoice: invoice_string.to_owned(),
                 amount,
+                max_fee: None,
             });
             add_metadata(&mut request, macaroon).unwrap_or_else(|_| exit(1));
             match client.pay_invoice(request).await {

src/lib.rs

@@ -289,6 +289,7 @@ pub struct PayOfferParams {
     /// The amount of time in seconds that we will wait for the offer creator to respond with
     /// an invoice. If not provided, we will use the default value of 15 seconds.
     pub response_invoice_timeout: Option<u32>,
+    pub max_fee: Option<u64>,
 }
 
 impl OfferHandler {
@@ -312,9 +313,9 @@ impl OfferHandler {
     /// offer.
     pub async fn pay_offer(&self, cfg: PayOfferParams) -> Result<Payment, OfferError> {
         let client_clone = cfg.client.clone();
+        let max_fee: Option<u64> = cfg.max_fee.clone();
         let (invoice, validated_amount, payment_id) = self.get_invoice(cfg).await?;
-
-        self.pay_invoice(client_clone, validated_amount, &invoice, payment_id)
+        self.pay_invoice(client_clone, validated_amount, &invoice, payment_id, max_fee)
             .await
     }
 
@@ -385,6 +386,7 @@ impl OfferHandler {
         amount: u64,
         invoice: &Bolt12Invoice,
         payment_id: PaymentId,
+        max_fee: Option<u64>,
     ) -> Result<Payment, OfferError> {
         let payment_hash = invoice.payment_hash();
         let path_info = invoice.payment_paths()[0].clone();
@@ -397,6 +399,7 @@ impl OfferHandler {
             payment_hash: payment_hash.0,
             msats: amount,
             payment_id,
+            max_fee,
         };
 
         let intro_node_id = match params.path.introduction_node {

src/lndk_offers.rs

@@ -329,8 +329,18 @@ impl OfferHandler {
             .await
             .map_err(OfferError::RouteFailure)?;
 
+        let route: Route = resp.routes[0].clone();
+        if let Some(max_fee) = params.max_fee {
+            let route_fee = route.total_fees_msat as u64;
+            if route_fee > max_fee {
+                return Err(OfferError::RouteFailure(Status::unknown(
+                    "Route fee is greater than max fee",
+                )));
+            }
+        }
+
         let _ = payer
-            .send_to_route(params.payment_hash, resp.routes[0].clone())
+            .send_to_route(params.payment_hash, route)
             .await
             .map_err(OfferError::RouteFailure)?;
 
@@ -357,6 +367,7 @@ pub struct SendPaymentParams {
     pub payment_hash: [u8; 32],
     pub msats: u64,
     pub payment_id: PaymentId,
+    pub max_fee: Option<u64>,
 }
 
 /// Checks that the user-provided amount matches the provided offer or invoice.
@@ -1239,6 +1250,7 @@ mod tests {
             payment_hash: payment_hash,
             msats: 2000,
             payment_id,
+            max_fee: None,
         };
         assert!(handler.send_payment(payer_mock, params).await.is_ok());
     }
@@ -1263,6 +1275,7 @@ mod tests {
             payment_hash: payment_hash,
             msats: 2000,
             payment_id,
+            max_fee: None,
         };
         assert!(handler.send_payment(payer_mock, params).await.is_err());
     }
@@ -1297,6 +1310,7 @@ mod tests {
             payment_hash: payment_hash,
             msats: 2000,
             payment_id,
+            max_fee: None,
         };
         assert!(handler.send_payment(payer_mock, params).await.is_err());
     }

src/server.rs

@@ -114,6 +114,7 @@ impl Offers for LNDKServer {
             destination,
             reply_path: Some(reply_path),
             response_invoice_timeout: inner_request.response_invoice_timeout,
+            max_fee: inner_request.max_fee,
         };
 
         let payment = match self.offer_handler.pay_offer(cfg).await {
@@ -208,6 +209,7 @@ impl Offers for LNDKServer {
             destination,
             reply_path: Some(reply_path),
             response_invoice_timeout: inner_request.response_invoice_timeout,
+            max_fee: None,
         };
 
         let (invoice, _, payment_id) = match self.offer_handler.get_invoice(cfg).await {
@@ -270,9 +272,10 @@ impl Offers for LNDKServer {
             Err(e) => return Err(Status::invalid_argument(e.to_string())),
         };
         let payment_id = PaymentId(self.offer_handler.messenger_utils.get_secure_random_bytes());
+        let max_fee: Option<u64> = inner_request.max_fee.into();
         let invoice = match self
             .offer_handler
-            .pay_invoice(client, amount, &invoice, payment_id)
+            .pay_invoice(client, amount, &invoice, payment_id, max_fee)
             .await
         {
             Ok(invoice) => {

tests/integration_tests.rs

@@ -58,6 +58,7 @@ async fn create_offers(
             destination: Destination::BlindedPath(blinded_path),
             reply_path: Some(reply_path),
             response_invoice_timeout: None,
+            max_fee: None,
         };
 
         pay_cfgs.push(pay_cfg);
@@ -344,6 +345,7 @@ async fn test_lndk_pay_offer() {
         destination: Destination::BlindedPath(blinded_path.clone()),
         reply_path: Some(reply_path),
         response_invoice_timeout: None,
+        max_fee: None
     };
     select! {
         val = messenger.run(lndk_cfg.clone(), Arc::clone(&handler)) => {
@@ -401,6 +403,7 @@ async fn test_lndk_pay_offer_concurrently() {
         destination: Destination::BlindedPath(blinded_path.clone()),
         reply_path: Some(reply_path),
         response_invoice_timeout: None,
+        max_fee: None,
     };
     // Let's also try to pay the same offer multiple times concurrently.
     select! {