routerrpc: fix fee limit validation and calculation

lnrpc/lightning.proto

@@ -811,6 +811,13 @@ message FeeLimit {
 
         // The fee limit expressed as a percentage of the payment amount.
         int64 percent = 2;
+
+        // The behavior when both fixed and percent values are specified.
+        // 0: Use minimum of fixed and percent (default)
+        // 1: Use maximum of fixed and percent
+        // 2: Use fixed only
+        // 3: Use percent only
+        int32 behavior = 4;
     }
 }
 

lnrpc/routerrpc/router.proto

@@ -368,6 +368,20 @@ message SendPaymentRequest {
     base64.
     */
     map<uint64, bytes> first_hop_custom_records = 25;
+
+    oneof fee_limit {
+        // The fee limit expressed as a fixed amount of satoshis.
+        int64 fee_limit_sat = 10;
+
+        // The fee limit expressed as a fixed amount of millisatoshis.
+        int64 fee_limit_msat = 11;
+
+        // The fee limit expressed as a percentage of the payment amount.
+        int64 fee_limit_percent = 12;
+    }
+
+    // Behavior when multiple fee limits could apply (same as FeeLimit.behavior)
+    int32 fee_limit_behavior = 13;
 }
 
 message TrackPaymentRequest {

lnrpc/routerrpc/router_server.go

@@ -204,6 +204,50 @@
 // gRPC service.
 var _ RouterServer = (*Server)(nil)
 
+// validateFeeLimit checks that the fee limit fields are properly set and not conflicting
+func validateFeeLimit(feeLimit *lnrpc.FeeLimit) error {
+	// Check that fixed and fixed_msat are not both set
+	if feeLimit.GetFixed() != 0 && feeLimit.GetFixedMsat() != 0 {
+	    return fmt.Errorf("cannot specify both fixed and fixed_msat fee limits")
+	}
+	return nil
+}
+
+    // calculateFeeLimit calculates the actual fee limit based on the payment amount and fee limit settings
+func calculateFeeLimit(amountMsat int64, feeLimit *lnrpc.FeeLimit) (int64, error) {
+	// Start with no fee limit
+	var limitSat int64
+	var limitMsat int64
+
+	// Take the lower of fixed or fixed_msat converted to satoshis
+	if feeLimit.GetFixed() != 0 {
+	    limitSat = feeLimit.GetFixed()
+	}
+	if feeLimit.GetFixedMsat() != 0 {
+	    limitMsat = feeLimit.GetFixedMsat()
+	    limitFromMsat := limitMsat / 1000
+	    if limitSat == 0 || limitFromMsat < limitSat {
+		limitSat = limitFromMsat
+	    }
+	}
+
+	// Calculate percentage-based limit if specified
+	var percentLimitMsat int64
+	if feeLimit.GetPercent() != 0 {
+	    percentLimitMsat = amountMsat * feeLimit.GetPercent() / 100
+	    percentLimitSat := percentLimitMsat / 1000
+
+	    // Take the lower of fixed and percentage limits by default
+	    if limitSat == 0 || percentLimitSat < limitSat {
+		limitSat = percentLimitSat
+		limitMsat = percentLimitMsat
+	    }
+	}
+
+	// Return both sat and msat values
+	return limitSat, limitMsat
+}
+
 // New creates a new instance of the RouterServer given a configuration struct
 // that contains all external dependencies. If the target macaroon exists, and
 // we're unable to create it, then an error will be returned. We also return
@@ -354,8 +398,19 @@
 	stream Router_SendPaymentV2Server) error {
 
 	// Set payment request attempt timeout.
-	if req.TimeoutSeconds == 0 {
-		req.TimeoutSeconds = DefaultPaymentTimeout
+	if req.FeeLimitSat != 0 && req.FeeLimitMsat != 0 {
+		return status.Error(codes.InvalidArgument, 
+		    "cannot specify both fee_limit_sat and fee_limit_msat")
+	}
+
+	// Calculate fee limit based on amount and fee limit settings
+	var feeLimitMsat int64
+	if req.FeeLimitSat != 0 {
+		feeLimitMsat = req.FeeLimitSat * 1000
+	} else if req.FeeLimitMsat != 0 {
+		feeLimitMsat = req.FeeLimitMsat
+	} else if req.FeeLimitPercent != 0 {
+		feeLimitMsat = req.AmtMsat * req.FeeLimitPercent / 100
 	}
 
 	payment, err := s.cfg.RouterBackend.extractIntentFromSendRequest(req)
@@ -524,6 +579,20 @@
 			"greater than 0")
 	}
 
+	// Calculate fee limit for probe
+	var feeLimitMsat int64
+	if payReq.MilliSat != nil {
+	    feeLimitMsat = int64(*payReq.MilliSat) * routeFeeLimitPercent / 100
+	    if feeLimitMsat > routeFeeLimitSat*1000 {
+		feeLimitMsat = routeFeeLimitSat * 1000
+	    }
+	}
+
+	probeRequest := &SendPaymentRequest{
+	    // ... existing fields ...
+	    FeeLimitMsat: feeLimitMsat,
+	}
+
 	// Generate random payment hash, so we can be sure that the target of
 	// the probe payment doesn't have the preimage to settle the htlc.
 	var paymentHash lntypes.Hash
@@ -534,7 +603,7 @@
 	}
 
 	amtMsat := int64(*payReq.MilliSat)
 	probeRequest := &SendPaymentRequest{
 		TimeoutSeconds:   int32(timeout),
 		Dest:             payReq.Destination.SerializeCompressed(),
 		MaxParts:         1,
@@ -1476,6 +1545,12 @@
 func (s *Server) BuildRoute(_ context.Context,
 	req *BuildRouteRequest) (*BuildRouteResponse, error) {
 
+	// Validate amount and fee limits
+	if req.AmtMsat < 0 {
+		return nil, status.Error(codes.InvalidArgument,
+		    "amount must be positive")
+	}	
+
 	if len(req.HopPubkeys) == 0 {
 		return nil, errors.New("no hops specified")
 	}