Merge pull request #8136 from hieblmi/fee-estimation-probe

Probing for more reliable route fee estimation

cmd/lncli/cmd_payments.go

@@ -1799,10 +1799,100 @@ func deletePayments(ctx *cli.Context) error {
 	return nil
 }
 
+var estimateRouteFeeCommand = cli.Command{
+	Name:     "estimateroutefee",
+	Category: "Payments",
+	Usage:    "Estimate routing fees based on a destination or an invoice.",
+	Action:   actionDecorator(estimateRouteFee),
+	Flags: []cli.Flag{
+		cli.StringFlag{
+			Name: "dest",
+			Usage: "the 33-byte hex-encoded public key for the " +
+				"probe destination. If it is specified then " +
+				"the amt flag is required. If it isn't " +
+				"specified then the pay_req field has to.",
+		},
+		cli.Int64Flag{
+			Name: "amt",
+			Usage: "the payment amount expressed in satoshis " +
+				"that should be probed for. This field is " +
+				"mandatory if dest is specified.",
+		},
+		cli.StringFlag{
+			Name: "pay_req",
+			Usage: "a zpay32 encoded payment request which is " +
+				"used to probe. If the destination is " +
+				"not public then route hints are scanned for " +
+				"a public node.",
+		},
+		cli.DurationFlag{
+			Name: "timeout",
+			Usage: "a deadline for the probe attempt. Only " +
+				"applicable if pay_req is specified.",
+			Value: paymentTimeout,
+		},
+	},
+}
+
+func estimateRouteFee(ctx *cli.Context) error {
+	ctxc := getContext()
+	conn := getClientConn(ctx, false)
+	defer conn.Close()
+
+	client := routerrpc.NewRouterClient(conn)
+
+	req := &routerrpc.RouteFeeRequest{}
+
+	switch {
+	case ctx.IsSet("dest") && ctx.IsSet("pay_req"):
+		return fmt.Errorf("either dest or pay_req can be set")
+
+	case ctx.IsSet("dest") && !ctx.IsSet("amt"):
+		return fmt.Errorf("amt is required when dest is set")
+
+	case ctx.IsSet("dest"):
+		dest, err := hex.DecodeString(ctx.String("dest"))
+		if err != nil {
+			return err
+		}
+
+		if len(dest) != 33 {
+			return fmt.Errorf("dest node pubkey must be exactly "+
+				"33 bytes, is instead: %v", len(dest))
+		}
+
+		amtSat := ctx.Int64("amt")
+		if amtSat == 0 {
+			return fmt.Errorf("non-zero amount required")
+		}
+
+		req.Dest = dest
+		req.AmtSat = amtSat
+
+	case ctx.IsSet("pay_req"):
+		req.PaymentRequest = stripPrefix(ctx.String("pay_req"))
+		if ctx.IsSet("timeout") {
+			req.Timeout = uint32(ctx.Duration("timeout").Seconds())
+		}
+
+	default:
+		return fmt.Errorf("fee estimation arguments missing")
+	}
+
+	resp, err := client.EstimateRouteFee(ctxc, req)
+	if err != nil {
+		return err
+	}
+
+	printRespJSON(resp)
+
+	return nil
+}
+
 // ESC is the ASCII code for escape character.
 const ESC = 27
 
-// clearCode defines a terminal escape code to clear the currently line and move
+// clearCode defines a terminal escape code to clear the current line and move
 // the cursor up.
 var clearCode = fmt.Sprintf("%c[%dA%c[2K", ESC, 1, ESC)
 

cmd/lncli/main.go

@@ -507,6 +507,7 @@ func main() {
 		subscribeCustomCommand,
 		fishCompletionCommand,
 		listAliasesCommand,
+		estimateRouteFeeCommand,
 	}
 
 	// Add any extra commands determined by build flags.

docs/release-notes/release-notes-0.18.0.md

@@ -221,9 +221,15 @@
   error is defined as a routing error found in one of a MPP's HTLC attempts.
   If, however, there's only one HTLC attempt, when it's failed, this payment is
   considered failed, thus there's no such thing as temp error for a non-MPP.
+
 * Support for
   [MinConf](https://github.com/lightningnetwork/lnd/pull/8097)(minimum number
   of confirmations) has been added to the `WalletBalance` RPC call.
+ 
+* [EstimateRouteFee](https://github.com/lightningnetwork/lnd/pull/8136) extends
+  the graph based estimation by a payment probe approach which can lead to more
+  accurate estimates. The new estimation method manually incorporates fees of
+  destinations that lie hidden behind lightning service providers.
 
 * `PendingChannels` now optionally returns the 
   [raw hex of the closing tx](https://github.com/lightningnetwork/lnd/pull/8426)
@@ -250,6 +256,9 @@
 * `pendingchannels` now optionally returns the 
   [raw hex of the closing tx](https://github.com/lightningnetwork/lnd/pull/8426)
   in `waiting_close_channels`.
+ 
+* The [estimateroutefee](https://github.com/lightningnetwork/lnd/pull/8136)
+  subcommand now gives access to graph based and payment probe fee estimation.
 
 ## Code Health
 
@@ -346,10 +355,10 @@
 * Keagan McClelland
 * Marcos Fernandez Perez
 * Matt Morehouse
+* Ononiwu Maureen Chiamaka
 * Slyghtning
 * Tee8z
 * Turtle
-* Ononiwu Maureen Chiamaka
 * w3irdrobot
 * Yong Yu
 * Ziggie

itest/list_on_test.go

@@ -257,6 +257,10 @@ var allTestCases = []*lntest.TestCase{
 		Name:     "multi-hop payments",
 		TestFunc: testMultiHopPayments,
 	},
+	{
+		Name:     "estimate route fee",
+		TestFunc: testEstimateRouteFee,
+	},
 	{
 		Name:     "anchors reserved value",
 		TestFunc: testAnchorReservedValue,

itest/lnd_amp_test.go

@@ -89,7 +89,14 @@ func testSendPaymentAMPInvoiceCase(ht *lntest.HarnessTest,
 	// Increase Dave's fee to make the test deterministic. Otherwise it
 	// would be unpredictable whether pathfinding would go through Charlie
 	// or Dave for the first shard.
-	expectedPolicy := mts.updateDaveGlobalPolicy()
+	expectedPolicy := &lnrpc.RoutingPolicy{
+		FeeBaseMsat:      500_000,
+		FeeRateMilliMsat: int64(0.001 * 1_000_000),
+		TimeLockDelta:    40,
+		MinHtlc:          1000, // default value
+		MaxHtlcMsat:      133_650_000,
+	}
+	mts.dave.UpdateGlobalPolicy(expectedPolicy)
 
 	// Make sure Alice has heard it for both Dave's channels.
 	ht.AssertChannelPolicyUpdate(
@@ -382,10 +389,17 @@ func testSendPaymentAMP(ht *lntest.HarnessTest) {
 	mts.openChannels(mppReq)
 	chanPointAliceDave := mts.channelPoints[1]
 
-	// Increase Dave's fee to make the test deterministic. Otherwise it
+	// Increase Dave's fee to make the test deterministic. Otherwise, it
 	// would be unpredictable whether pathfinding would go through Charlie
 	// or Dave for the first shard.
-	expectedPolicy := mts.updateDaveGlobalPolicy()
+	expectedPolicy := &lnrpc.RoutingPolicy{
+		FeeBaseMsat:      500_000,
+		FeeRateMilliMsat: int64(0.001 * 1_000_000),
+		TimeLockDelta:    40,
+		MinHtlc:          1000, // default value
+		MaxHtlcMsat:      133_650_000,
+	}
+	mts.dave.UpdateGlobalPolicy(expectedPolicy)
 
 	// Make sure Alice has heard it.
 	ht.AssertChannelPolicyUpdate(
@@ -493,7 +507,7 @@ func testSendToRouteAMP(ht *lntest.HarnessTest) {
 	// Alice -- Carol ---- Bob
 	//      \              /
 	//       \__ Dave ____/
-	///
+	//
 	mppReq := &mppOpenChannelRequest{
 		// Since the channel Alice-> Carol will have to carry two
 		// shards, we make it larger.

itest/lnd_estimate_route_fee_test.go

@@ -0,0 +1,405 @@
+package itest
+
+import (
+	"testing"
+
+	"github.com/btcsuite/btcd/btcutil"
+	"github.com/lightningnetwork/lnd/chainreg"
+	"github.com/lightningnetwork/lnd/lnrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
+	"github.com/lightningnetwork/lnd/lntest"
+	"github.com/lightningnetwork/lnd/lntest/node"
+	"github.com/lightningnetwork/lnd/routing"
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	probeInitiator *node.HarnessNode
+	probeAmount    = btcutil.Amount(100_000)
+	probeAmt       = int64(probeAmount) * 1_000
+
+	failureReasonNone    = lnrpc.PaymentFailureReason_FAILURE_REASON_NONE
+	failureReasonNoRoute = lnrpc.PaymentFailureReason_FAILURE_REASON_NO_ROUTE //nolint:lll
+)
+
+const (
+	ErrNoRouteInGraph = "unable to find a path to destination"
+)
+
+type estimateRouteFeeTestCase struct {
+	// name is the name of the target test case.
+	name string
+
+	// probing is a flag that indicates whether the test case estimates fees
+	// using the graph or by probing.
+	probing bool
+
+	// destination is the node that will receive the probe.
+	destination *node.HarnessNode
+
+	// routeHints are the route hints that will be used for the probe.
+	routeHints []*lnrpc.RouteHint
+
+	// expectedRoutingFeesMsat are the expected routing fees that will be
+	// returned by the probe.
+	expectedRoutingFeesMsat int64
+
+	// expectedCltvDelta is the expected cltv delta that will be returned by
+	// the fee estimation.
+	expectedCltvDelta int64
+
+	// expectedFailureReason is the expected payment failure reason that
+	// will be returned by the probe.
+	expectedFailureReason lnrpc.PaymentFailureReason
+
+	// expectedError are the expected error that will be returned if the
+	// probing fails.
+	expectedError string
+}
+
+// testEstimateRouteFee tests the estimation of routing fees using either graph
+// data or sending out a probe payment.
+func testEstimateRouteFee(ht *lntest.HarnessTest) {
+	mts := newMppTestScenario(ht)
+
+	// We extend the regular mpp test scenario with a new node Paula. Paula
+	// is connected to Bob and Eve through private channels.
+	//                  /-------------\
+	//              _ Eve _  (private) \
+	//             /       \            \
+	// Alice -- Carol ---- Bob --------- Paula
+	//      \              /   (private)
+	//       \__ Dave ____/
+	//
+	req := &mppOpenChannelRequest{
+		amtAliceCarol: 200_000,
+		amtAliceDave:  200_000,
+		amtCarolBob:   200_000,
+		amtCarolEve:   200_000,
+		amtDaveBob:    200_000,
+		amtEveBob:     200_000,
+	}
+	mts.openChannels(req)
+	chanPointDaveBob := mts.channelPoints[4]
+	chanPointEveBob := mts.channelPoints[5]
+
+	// Alice will initiate all probe payments.
+	probeInitiator = mts.alice
+
+	paula := ht.NewNode("Paula", nil)
+
+	// The channel from Bob to Paula actually doesn't have enough liquidity
+	// to carry out the probe. We assume in normal operation that hop hints
+	// added to the invoice always have enough liquidity, but here we check
+	// that the prober uses the more expensive route.
+	ht.EnsureConnected(mts.bob, paula)
+	channelPointBobPaula := ht.OpenChannel(
+		mts.bob, paula, lntest.OpenChannelParams{
+			Private: true,
+			Amt:     90_000,
+			PushAmt: 69_000,
+		},
+	)
+
+	ht.EnsureConnected(mts.eve, paula)
+	channelPointEvePaula := ht.OpenChannel(
+		mts.eve, paula, lntest.OpenChannelParams{
+			Private: true,
+			Amt:     1_000_000,
+		},
+	)
+
+	bobsPrivChannels := ht.Bob.RPC.ListChannels(&lnrpc.ListChannelsRequest{
+		PrivateOnly: true,
+	})
+	require.Len(ht, bobsPrivChannels.Channels, 1)
+	bobPaulaChanID := bobsPrivChannels.Channels[0].ChanId
+
+	evesPrivChannels := mts.eve.RPC.ListChannels(&lnrpc.ListChannelsRequest{
+		PrivateOnly: true,
+	})
+	require.Len(ht, evesPrivChannels.Channels, 1)
+	evePaulaChanID := evesPrivChannels.Channels[0].ChanId
+
+	// Let's disable the paths from Alice to Bob through Dave and Eve with
+	// high fees. This ensures that the path estimates are based on Carol's
+	// channel to Bob for the first set of tests.
+	expectedPolicy := &lnrpc.RoutingPolicy{
+		FeeBaseMsat:      200_000,
+		FeeRateMilliMsat: int64(0.001 * 1_000_000),
+		TimeLockDelta:    40,
+		MinHtlc:          1000, // default value
+		MaxHtlcMsat:      133_650_000,
+	}
+	mts.dave.UpdateGlobalPolicy(expectedPolicy)
+	ht.AssertChannelPolicyUpdate(
+		mts.alice, mts.dave, expectedPolicy, chanPointDaveBob, false,
+	)
+	expectedPolicy.FeeBaseMsat = 500_000
+	mts.eve.UpdateGlobalPolicy(expectedPolicy)
+	ht.AssertChannelPolicyUpdate(
+		mts.alice, mts.eve, expectedPolicy, chanPointEveBob, false,
+	)
+
+	var (
+		bobHopHint = &lnrpc.HopHint{
+			NodeId:                    mts.bob.PubKeyStr,
+			FeeBaseMsat:               1_000,
+			FeeProportionalMillionths: 1,
+			CltvExpiryDelta:           100,
+			ChanId:                    bobPaulaChanID,
+		}
+
+		bobExpHint = &lnrpc.HopHint{
+			NodeId:                    mts.bob.PubKeyStr,
+			FeeBaseMsat:               2000,
+			FeeProportionalMillionths: 2000,
+			CltvExpiryDelta:           80,
+			ChanId:                    bobPaulaChanID,
+		}
+
+		eveHopHint = &lnrpc.HopHint{
+			NodeId:                    mts.eve.PubKeyStr,
+			FeeBaseMsat:               1_000_000,
+			FeeProportionalMillionths: 1,
+			CltvExpiryDelta:           200,
+			ChanId:                    evePaulaChanID,
+		}
+
+		singleRouteHint = []*lnrpc.RouteHint{
+			{
+				HopHints: []*lnrpc.HopHint{
+					bobHopHint,
+				},
+			},
+		}
+
+		lspDifferentFeesHints = []*lnrpc.RouteHint{
+			{
+				HopHints: []*lnrpc.HopHint{
+					bobHopHint,
+				},
+			},
+			{
+				HopHints: []*lnrpc.HopHint{
+					bobExpHint,
+				},
+			},
+		}
+
+		nonLspProbingRouteHints = []*lnrpc.RouteHint{
+			{
+				HopHints: []*lnrpc.HopHint{
+					eveHopHint,
+				},
+			},
+			{
+				HopHints: []*lnrpc.HopHint{
+					bobHopHint,
+				},
+			},
+		}
+	)
+
+	defaultTimelock := int64(chainreg.DefaultBitcoinTimeLockDelta)
+
+	// Going A -> Carol -> Bob
+	feeStandardSingleHop := int64(1_000) + probeAmt/1_000_000
+
+	// Going A -> Carol -> Bob -> Paula/no node
+	feeBP := int64(bobHopHint.FeeBaseMsat) +
+		int64(bobHopHint.FeeProportionalMillionths)*(probeAmt)/1_000_000
+	deltaBP := int64(bobHopHint.CltvExpiryDelta)
+
+	feeCB := int64(1_000) + (probeAmt+feeBP)/1_000_000
+	deltaCB := defaultTimelock
+
+	deltaACBP := deltaCB + deltaBP
+	feeACBP := feeCB + feeBP
+
+	// The expensive alternative to Bob.
+	expFeeBP := int64(bobExpHint.FeeBaseMsat) +
+		int64(bobExpHint.FeeProportionalMillionths)*(probeAmt)/1_000_000
+	expFeeCB := int64(1_000) + (probeAmt+expFeeBP)/1_000_000
+	expensiveFeeACBP := expFeeCB + expFeeBP
+
+	// Going A -> Carol -> Eve -> Paula
+	feeEP := int64(eveHopHint.FeeBaseMsat) +
+		int64(eveHopHint.FeeProportionalMillionths)*(probeAmt)/1_000_000
+	deltaEP := int64(eveHopHint.CltvExpiryDelta)
+
+	feeCE := int64(1_000) + (probeAmt+feeEP)/1_000_000
+	deltaCE := defaultTimelock
+
+	feeACEP := feeEP + feeCE
+	deltaACEP := deltaCE + deltaEP
+
+	initialBlockHeight := int64(mts.alice.RPC.GetInfo().BlockHeight)
+
+	// Locktime is always composed of the initial block height and the
+	// time lock delta for the first hop. Additionally, there's a block
+	// accounting for block height variance.
+	locktime := initialBlockHeight + defaultTimelock +
+		int64(routing.BlockPadding)
+
+	var testCases = []*estimateRouteFeeTestCase{
+		// Single hop payment is free.
+		{
+			name:                    "graph based estimate, 0 fee",
+			probing:                 false,
+			destination:             mts.dave,
+			expectedRoutingFeesMsat: 0,
+			expectedCltvDelta:       locktime,
+			expectedFailureReason:   failureReasonNone,
+		},
+		// 1000 msat base fee + 100 msat(1ppm*100_000sat)
+		{
+			name:                    "graph based estimate",
+			probing:                 false,
+			destination:             mts.bob,
+			expectedRoutingFeesMsat: feeStandardSingleHop,
+			expectedCltvDelta:       locktime + deltaCB,
+			expectedFailureReason:   failureReasonNone,
+		},
+		// We expect the same result as the graph based estimate to Bob.
+		{
+			name: "probe based estimate, empty " +
+				"route hint",
+			probing:                 true,
+			destination:             mts.bob,
+			routeHints:              []*lnrpc.RouteHint{},
+			expectedRoutingFeesMsat: feeStandardSingleHop,
+			expectedCltvDelta:       locktime + deltaCB,
+			expectedFailureReason:   failureReasonNone,
+		},
+		// We expect the previous probing results adjusted by Paula's
+		// hop data.
+		{
+			name: "probe based estimate, single" +
+				" route hint",
+			probing:                 true,
+			destination:             paula,
+			routeHints:              singleRouteHint,
+			expectedRoutingFeesMsat: feeACBP,
+			expectedCltvDelta:       locktime + deltaACBP,
+			expectedFailureReason:   failureReasonNone,
+		},
+		// With multiple route hints and lsp detected, we expect the
+		// highest of fee settings to be used for estimation.
+		{
+			name: "probe based estimate, " +
+				"multiple route hints, diff lsp fees",
+			probing:                 true,
+			destination:             paula,
+			routeHints:              lspDifferentFeesHints,
+			expectedRoutingFeesMsat: expensiveFeeACBP,
+			expectedCltvDelta:       locktime + deltaACBP,
+			expectedFailureReason:   failureReasonNone,
+		},
+		// A destination without channels and an existing hop hint hop
+		// should result in the same estimate as if the hidden node was
+		// connected through a channel. This ensures that the probe is
+		// actually just send to the LSP and not the destination.
+		{
+			name: "single hop hint, destination " +
+				"without channels",
+			probing: true,
+			destination: ht.NewNode(
+				"ImWithoutChannels", nil,
+			),
+			routeHints:              singleRouteHint,
+			expectedRoutingFeesMsat: feeACBP,
+			expectedCltvDelta:       locktime + deltaACBP,
+			expectedFailureReason:   failureReasonNone,
+		},
+		// Test lnd native hop processing with non lsp probing. Paula is
+		// lacking liqudity in the channel to Bob, so Eve is used, but
+		// it has higher fees.
+		{
+			name: "probe based estimate, non " +
+				"lsp",
+			probing:                 true,
+			destination:             paula,
+			routeHints:              nonLspProbingRouteHints,
+			expectedRoutingFeesMsat: feeACEP,
+			expectedCltvDelta:       locktime + deltaACEP,
+			expectedFailureReason:   failureReasonNone,
+		},
+		// We expect a NO_ROUTE error if route hints to paula aren't
+		// provided while probing the graph.
+		{
+			name:          "no route via graph",
+			probing:       false,
+			destination:   paula,
+			expectedError: ErrNoRouteInGraph,
+		},
+		// We expect a NO_ROUTE error if route hints to paula aren't
+		// provided while sending a probe payment.
+		{
+			name:                    "no route via probe",
+			probing:                 true,
+			destination:             paula,
+			expectedRoutingFeesMsat: 0,
+			expectedCltvDelta:       0,
+			expectedFailureReason:   failureReasonNoRoute,
+		},
+	}
+
+	for _, testCase := range testCases {
+		success := ht.Run(
+			testCase.name, func(tt *testing.T) {
+				runFeeEstimationTestCase(ht, testCase)
+			},
+		)
+
+		if !success {
+			break
+		}
+	}
+
+	mts.ht.CloseChannelAssertPending(mts.bob, channelPointBobPaula, false)
+	mts.ht.CloseChannelAssertPending(mts.eve, channelPointEvePaula, false)
+	mts.closeChannels()
+}
+
+// runTestCase runs a single test case asserting that test conditions are met.
+func runFeeEstimationTestCase(ht *lntest.HarnessTest,
+	tc *estimateRouteFeeTestCase) {
+
+	// Legacy graph based fee estimation.
+	var feeReq *routerrpc.RouteFeeRequest
+	if tc.probing {
+		payReqs, _, _ := ht.CreatePayReqs(
+			tc.destination, probeAmount, 1, tc.routeHints...,
+		)
+		feeReq = &routerrpc.RouteFeeRequest{
+			PaymentRequest: payReqs[0],
+			Timeout:        10,
+		}
+	} else {
+		feeReq = &routerrpc.RouteFeeRequest{
+			Dest:   tc.destination.PubKey[:],
+			AmtSat: int64(probeAmount),
+		}
+	}
+
+	ctx := ht.Context()
+
+	// Kick off the parametrized fee estimation.
+	resp, err := probeInitiator.RPC.Router.EstimateRouteFee(ctx, feeReq)
+	if err != nil {
+		require.ErrorContains(ht, err, tc.expectedError)
+
+		return
+	}
+
+	require.Equal(ht, tc.expectedFailureReason, resp.FailureReason)
+	require.Equal(
+		ht, tc.expectedRoutingFeesMsat, resp.RoutingFeeMsat,
+		"routing fees",
+	)
+	require.Equal(
+		ht, tc.expectedCltvDelta, resp.TimeLockDelay,
+		"cltv delta",
+	)
+}

itest/lnd_mpp_test.go

@@ -347,33 +347,3 @@ func (m *mppTestScenario) buildRoute(amt btcutil.Amount,
 
 	return routeResp.Route
 }
-
-// updatePolicy updates a Dave's global channel policy and returns the expected
-// policy for further check. It changes Dave's `FeeBaseMsat` from 1000 msat to
-// 500,000 msat, and `FeeProportionalMillonths` from 1 msat to 1000 msat.
-func (m *mppTestScenario) updateDaveGlobalPolicy() *lnrpc.RoutingPolicy {
-	const (
-		baseFeeMsat = 500_000
-		feeRate     = 0.001
-		maxHtlcMsat = 133_650_000
-	)
-
-	expectedPolicy := &lnrpc.RoutingPolicy{
-		FeeBaseMsat:      baseFeeMsat,
-		FeeRateMilliMsat: feeRate * testFeeBase,
-		TimeLockDelta:    40,
-		MinHtlc:          1000, // default value
-		MaxHtlcMsat:      maxHtlcMsat,
-	}
-
-	updateFeeReq := &lnrpc.PolicyUpdateRequest{
-		BaseFeeMsat:   baseFeeMsat,
-		FeeRate:       feeRate,
-		TimeLockDelta: 40,
-		Scope:         &lnrpc.PolicyUpdateRequest_Global{Global: true},
-		MaxHtlcMsat:   maxHtlcMsat,
-	}
-	m.dave.RPC.UpdateChannelPolicy(updateFeeReq)
-
-	return expectedPolicy
-}

itest/lnd_send_multi_path_payment_test.go

@@ -38,10 +38,17 @@ func testSendMultiPathPayment(ht *lntest.HarnessTest) {
 	mts.openChannels(req)
 	chanPointAliceDave := mts.channelPoints[1]
 
-	// Increase Dave's fee to make the test deterministic. Otherwise it
+	// Increase Dave's fee to make the test deterministic. Otherwise, it
 	// would be unpredictable whether pathfinding would go through Charlie
 	// or Dave for the first shard.
-	expectedPolicy := mts.updateDaveGlobalPolicy()
+	expectedPolicy := &lnrpc.RoutingPolicy{
+		FeeBaseMsat:      500_000,
+		FeeRateMilliMsat: int64(0.001 * 1_000_000),
+		TimeLockDelta:    40,
+		MinHtlc:          1000, // default value
+		MaxHtlcMsat:      133_650_000,
+	}
+	mts.dave.UpdateGlobalPolicy(expectedPolicy)
 
 	// Make sure Alice has heard it.
 	ht.AssertChannelPolicyUpdate(

lnrpc/routerrpc/config.go

@@ -69,6 +69,7 @@ func DefaultConfig() *Config {
 			NodeWeight: routing.DefaultBimodalNodeWeight,
 			DecayTime:  routing.DefaultBimodalDecayTime,
 		},
+		FeeEstimationTimeout: routing.DefaultFeeEstimationTimeout,
 	}
 
 	return &Config{
@@ -96,5 +97,6 @@ func GetRoutingConfig(cfg *Config) *RoutingConfig {
 			NodeWeight: cfg.BimodalConfig.NodeWeight,
 			DecayTime:  cfg.BimodalConfig.DecayTime,
 		},
+		FeeEstimationTimeout: cfg.FeeEstimationTimeout,
 	}
 }

lnrpc/routerrpc/router.proto

@@ -353,14 +353,39 @@ message TrackPaymentsRequest {
 
 message RouteFeeRequest {
     /*
-    The destination once wishes to obtain a routing fee quote to.
+    The destination one wishes to obtain a routing fee quote to. If set, this
+    parameter requires the amt_sat parameter also to be set. This parameter
+    combination triggers a graph based routing fee estimation as opposed to a
+    payment probe based estimate in case a payment request is provided. The
+    graph based estimation is an algorithm that is executed on the in memory
+    graph. Hence its runtime is significantly shorter than a payment probe
+    estimation that sends out actual payments to the network.
     */
     bytes dest = 1;
 
     /*
-    The amount one wishes to send to the target destination.
+    The amount one wishes to send to the target destination. It is only to be
+    used in combination with the dest parameter.
     */
     int64 amt_sat = 2;
+
+    /*
+    A payment request of the target node that the route fee request is intended
+    for. Its parameters are input to probe payments that estimate routing fees.
+    The timeout parameter can be specified to set a maximum time on the probing
+    attempt. Cannot be used in combination with dest and amt_sat.
+    */
+    string payment_request = 3;
+
+    /*
+    A user preference of how long a probe payment should maximally be allowed to
+    take, denoted in seconds. The probing payment loop is aborted if this
+    timeout is reached. Note that the probing process itself can take longer
+    than the timeout if the HTLC becomes delayed or stuck. Canceling the context
+    of this call will not cancel the payment loop, the duration is only
+    controlled by the timeout parameter.
+    */
+    uint32 timeout = 4;
 }
 
 message RouteFeeResponse {
@@ -376,6 +401,12 @@ message RouteFeeResponse {
     value.
     */
     int64 time_lock_delay = 2;
+
+    /*
+    An indication whether a probing payment succeeded or whether and why it
+    failed. FAILURE_REASON_NONE indicates success.
+    */
+    lnrpc.PaymentFailureReason failure_reason = 5;
 }
 
 message SendToRouteRequest {

lnrpc/routerrpc/router.swagger.json

@@ -1642,12 +1642,21 @@
         "dest": {
           "type": "string",
           "format": "byte",
-          "description": "The destination once wishes to obtain a routing fee quote to."
+          "description": "The destination one wishes to obtain a routing fee quote to. If set, this\nparameter requires the amt_sat parameter also to be set. This parameter\ncombination triggers a graph based routing fee estimation as opposed to a\npayment probe based estimate in case a payment request is provided. The\ngraph based estimation is an algorithm that is executed on the in memory\ngraph. Hence its runtime is significantly shorter than a payment probe\nestimation that sends out actual payments to the network."
         },
         "amt_sat": {
           "type": "string",
           "format": "int64",
-          "description": "The amount one wishes to send to the target destination."
+          "description": "The amount one wishes to send to the target destination. It is only to be\nused in combination with the dest parameter."
+        },
+        "payment_request": {
+          "type": "string",
+          "description": "A payment request of the target node that the route fee request is intended\nfor. Its parameters are input to probe payments that estimate routing fees.\nThe timeout parameter can be specified to set a maximum time on the probing\nattempt. Cannot be used in combination with dest and amt_sat."
+        },
+        "timeout": {
+          "type": "integer",
+          "format": "int64",
+          "description": "A user preference of how long a probe payment should maximally be allowed to\ntake, denoted in seconds. The probing payment loop is aborted if this\ntimeout is reached. Note that the probing process itself can take longer\nthan the timeout if the HTLC becomes delayed or stuck. Canceling the context\nof this call will not cancel the payment loop, the duration is only\ncontrolled by the timeout parameter."
         }
       }
     },
@@ -1663,6 +1672,10 @@
           "type": "string",
           "format": "int64",
           "description": "An estimate of the worst case time delay that can occur. Note that callers\nwill still need to factor in the final CLTV delta of the last hop into this\nvalue."
+        },
+        "failure_reason": {
+          "$ref": "#/definitions/lnrpcPaymentFailureReason",
+          "description": "An indication whether a probing payment succeeded or whether and why it\nfailed. FAILURE_REASON_NONE indicates success."
         }
       }
     },

lnrpc/routerrpc/router_backend.go

@@ -1175,8 +1175,18 @@ func unmarshallHopHint(rpcHint *lnrpc.HopHint) (zpay32.HopHint, error) {
 	}, nil
 }
 
+// MarshalFeatures converts a feature vector into a list of uint32's.
+func MarshalFeatures(feats *lnwire.FeatureVector) []lnrpc.FeatureBit {
+	var featureBits []lnrpc.FeatureBit
+	for feature := range feats.Features() {
+		featureBits = append(featureBits, lnrpc.FeatureBit(feature))
+	}
+
+	return featureBits
+}
+
 // UnmarshalFeatures converts a list of uint32's into a valid feature vector.
-// This method checks that feature bit pairs aren't assigned toegether, and
+// This method checks that feature bit pairs aren't assigned together, and
 // validates transitive dependencies.
 func UnmarshalFeatures(
 	rpcFeatures []lnrpc.FeatureBit) (*lnwire.FeatureVector, error) {

lnrpc/routerrpc/router_server.go

@@ -1,7 +1,9 @@
 package routerrpc
 
 import (
+	"bytes"
 	"context"
+	crand "crypto/rand"
 	"errors"
 	"fmt"
 	"io/ioutil"
@@ -15,11 +17,13 @@ import (
 	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/lnrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/invoicesrpc"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/macaroons"
 	"github.com/lightningnetwork/lnd/routing"
 	"github.com/lightningnetwork/lnd/routing/route"
+	"github.com/lightningnetwork/lnd/zpay32"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
@@ -31,16 +35,26 @@ const (
 	// to register ourselves, and we also require that the main
 	// SubServerConfigDispatcher instance recognize as the name of our
 	subServerName = "RouterRPC"
+
+	// routeFeeLimitSat is the maximum routing fee that we allow to occur
+	// when estimating a routing fee.
+	routeFeeLimitSat = 100_000_000
 )
 
 var (
 	errServerShuttingDown = errors.New("routerrpc server shutting down")
 
-	// ErrInterceptorAlreadyExists is an error returned when the a new stream
-	// is opened and there is already one active interceptor.
-	// The user must disconnect prior to open another stream.
+	// ErrInterceptorAlreadyExists is an error returned when a new stream is
+	// opened and there is already one active interceptor. The user must
+	// disconnect prior to open another stream.
 	ErrInterceptorAlreadyExists = errors.New("interceptor already exists")
 
+	errMissingPaymentAttempt = errors.New("missing payment attempt")
+
+	errMissingRoute = errors.New("missing route")
+
+	errUnexpectedFailureSource = errors.New("unexpected failure source")
+
 	// macaroonOps are the set of capabilities that our minted macaroon (if
 	// it doesn't already exist) will have.
 	macaroonOps = []bakery.Op{
@@ -356,25 +370,58 @@ func (s *Server) SendPaymentV2(req *SendPaymentRequest,
 	)
 }
 
-// EstimateRouteFee allows callers to obtain a lower bound w.r.t how much it
-// may cost to send an HTLC to the target end destination.
+// EstimateRouteFee allows callers to obtain an expected value w.r.t how much it
+// may cost to send an HTLC to the target end destination. This method sends
+// probe payments to the target node, based on target invoice parameters and a
+// random payment hash that makes it impossible for the target to settle the
+// htlc. The probing stops if a user-provided timeout is reached. If provided
+// with a destination key and amount, this method will perform a local graph
+// based fee estimation.
 func (s *Server) EstimateRouteFee(ctx context.Context,
 	req *RouteFeeRequest) (*RouteFeeResponse, error) {
 
-	if len(req.Dest) != 33 {
-		return nil, errors.New("invalid length destination key")
+	isProbeDestination := len(req.Dest) > 0
+	isProbeInvoice := len(req.PaymentRequest) > 0
+
+	switch {
+	case isProbeDestination == isProbeInvoice:
+		return nil, errors.New("specify either a destination or an " +
+			"invoice")
+
+	case isProbeDestination:
+		switch {
+		case len(req.Dest) != 33:
+			return nil, errors.New("invalid length destination key")
+
+		case req.AmtSat <= 0:
+			return nil, errors.New("amount must be greater than 0")
+
+		default:
+			return s.probeDestination(req.Dest, req.AmtSat)
+		}
+
+	case isProbeInvoice:
+		return s.probePaymentRequest(
+			ctx, req.PaymentRequest, req.Timeout,
+		)
+	}
+
+	return &RouteFeeResponse{}, nil
+}
+
+// probeDestination estimates fees along a route to a destination based on the
+// contents of the local graph.
+func (s *Server) probeDestination(dest []byte, amtSat int64) (*RouteFeeResponse,
+	error) {
+
+	destNode, err := route.NewVertexFromBytes(dest)
+	if err != nil {
+		return nil, err
 	}
-	var destNode route.Vertex
-	copy(destNode[:], req.Dest)
 
 	// Next, we'll convert the amount in satoshis to mSAT, which are the
 	// native unit of LN.
-	amtMsat := lnwire.NewMSatFromSatoshis(btcutil.Amount(req.AmtSat))
-
-	// Pick a fee limit
-	//
-	// TODO: Change this into behaviour that makes more sense.
-	feeLimit := lnwire.NewMSatFromSatoshis(btcutil.SatoshiPerBitcoin)
+	amtMsat := lnwire.NewMSatFromSatoshis(btcutil.Amount(amtSat))
 
 	// Finally, we'll query for a route to the destination that can carry
 	// that target amount, we'll only request a single route. Set a
@@ -384,7 +431,7 @@ func (s *Server) EstimateRouteFee(ctx context.Context,
 	routeReq, err := routing.NewRouteRequest(
 		s.cfg.RouterBackend.SelfNode, &destNode, amtMsat, 0,
 		&routing.RestrictParams{
-			FeeLimit:          feeLimit,
+			FeeLimit:          routeFeeLimitSat,
 			CltvLimit:         s.cfg.RouterBackend.MaxTotalTimelock,
 			ProbabilitySource: mc.GetProbability,
 		}, nil, nil, nil, s.cfg.RouterBackend.DefaultFinalCltvDelta,
@@ -398,14 +445,379 @@ func (s *Server) EstimateRouteFee(ctx context.Context,
 		return nil, err
 	}
 
+	// We are adding a block padding to the total time lock to account for
+	// the safety buffer that the payment session will add to the last hop's
+	// cltv delta. This is to prevent the htlc from failing if blocks are
+	// mined while it is in flight.
+	timeLockDelay := route.TotalTimeLock + uint32(routing.BlockPadding)
+
 	return &RouteFeeResponse{
 		RoutingFeeMsat: int64(route.TotalFees()),
-		TimeLockDelay:  int64(route.TotalTimeLock),
+		TimeLockDelay:  int64(timeLockDelay),
+		FailureReason:  lnrpc.PaymentFailureReason_FAILURE_REASON_NONE,
 	}, nil
 }
 
-// SendToRouteV2 sends a payment through a predefined route. The response of this
-// call contains structured error information.
+// probePaymentRequest estimates fees along a route to a destination that is
+// specified in an invoice. The estimation duration is limited by a timeout. In
+// case that route hints are provided, this method applies a heuristic to
+// identify LSPs which might block probe payments. In that case, fees are
+// manually calculated and added to the probed fee estimation up until the LSP
+// node. If the route hints don't indicate an LSP, they are passed as arguments
+// to the SendPayment_V2 method, which enable it to send probe payments to the
+// payment request destination.
+func (s *Server) probePaymentRequest(ctx context.Context, paymentRequest string,
+	timeout uint32) (*RouteFeeResponse, error) {
+
+	payReq, err := zpay32.Decode(
+		paymentRequest, s.cfg.RouterBackend.ActiveNetParams,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	if *payReq.MilliSat <= 0 {
+		return nil, errors.New("payment request amount must be " +
+			"greater than 0")
+	}
+
+	// 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
+	_, err = crand.Read(paymentHash[:])
+	if err != nil {
+		return nil, fmt.Errorf("cannot generate random probe "+
+			"preimage: %w", err)
+	}
+
+	amtMsat := int64(*payReq.MilliSat)
+	probeRequest := &SendPaymentRequest{
+		TimeoutSeconds:   int32(timeout),
+		Dest:             payReq.Destination.SerializeCompressed(),
+		MaxParts:         1,
+		AllowSelfPayment: false,
+		AmtMsat:          amtMsat,
+		PaymentHash:      paymentHash[:],
+		FeeLimitSat:      routeFeeLimitSat,
+		PaymentAddr:      payReq.PaymentAddr[:],
+		FinalCltvDelta:   int32(payReq.MinFinalCLTVExpiry()),
+		DestFeatures:     MarshalFeatures(payReq.Features),
+	}
+
+	hints := payReq.RouteHints
+
+	// If the hints don't indicate an LSP then chances are that our probe
+	// payment won't be blocked along the route to the destination. We send
+	// a probe payment with unmodified route hints.
+	if !isLSP(hints) {
+		probeRequest.RouteHints = invoicesrpc.CreateRPCRouteHints(hints)
+		return s.sendProbePayment(ctx, probeRequest)
+	}
+
+	// If the heuristic indicates an LSP we modify the route hints to allow
+	// probing the LSP.
+	lspAdjustedRouteHints, lspHint, err := prepareLspRouteHints(
+		hints, *payReq.MilliSat,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	// The adjusted route hints serve the payment probe to find the last
+	// public hop to the LSP on the route.
+	probeRequest.Dest = lspHint.NodeID.SerializeCompressed()
+	if len(lspAdjustedRouteHints) > 0 {
+		probeRequest.RouteHints = invoicesrpc.CreateRPCRouteHints(
+			lspAdjustedRouteHints,
+		)
+	}
+
+	// The payment probe will be able to calculate the fee up until the LSP
+	// node. The fee of the last hop has to be calculated manually. Since
+	// the last hop's fee amount has to be sent across the payment path we
+	// have to add it to the original payment amount. Only then will the
+	// payment probe be able to determine the correct fee to the last hop
+	// prior to the private destination. For example, if the user wants to
+	// send 1000 sats to a private destination and the last hop's fee is 10
+	// sats, then 1010 sats will have to arrive at the last hop. This means
+	// that the probe has to be dispatched with 1010 sats to correctly
+	// calculate the routing fee.
+	//
+	// Calculate the hop fee for the last hop manually.
+	hopFee := lspHint.HopFee(*payReq.MilliSat)
+	if err != nil {
+		return nil, err
+	}
+
+	// Add the last hop's fee to the requested payment amount that we want
+	// to get an estimate for.
+	probeRequest.AmtMsat += int64(hopFee)
+
+	// Use the hop hint's cltv delta as the payment request's final cltv
+	// delta. The actual final cltv delta of the invoice will be added to
+	// the payment probe's cltv delta.
+	probeRequest.FinalCltvDelta = int32(lspHint.CLTVExpiryDelta)
+
+	// Dispatch the payment probe with adjusted fee amount.
+	resp, err := s.sendProbePayment(ctx, probeRequest)
+	if err != nil {
+		return nil, err
+	}
+
+	// If the payment probe failed we only return the failure reason and
+	// leave the probe result params unaltered.
+	if resp.FailureReason != lnrpc.PaymentFailureReason_FAILURE_REASON_NONE { //nolint:lll
+		return resp, nil
+	}
+
+	// The probe succeeded, so we can add the last hop's fee to fee the
+	// payment probe returned.
+	resp.RoutingFeeMsat += int64(hopFee)
+
+	// Add the final cltv delta of the invoice to the payment probe's total
+	// cltv delta. This is the cltv delta for the hop behind the LSP.
+	resp.TimeLockDelay += int64(payReq.MinFinalCLTVExpiry())
+
+	return resp, nil
+}
+
+// isLSP checks if the route hints indicate an LSP. An LSP is indicated with
+// true if the last node in each route hint has the same node id, false
+// otherwise.
+func isLSP(routeHints [][]zpay32.HopHint) bool {
+	if len(routeHints) == 0 || len(routeHints[0]) == 0 {
+		return false
+	}
+
+	refNodeID := routeHints[0][len(routeHints[0])-1].NodeID
+	for i := 1; i < len(routeHints); i++ {
+		// Skip empty route hints.
+		if len(routeHints[i]) == 0 {
+			continue
+		}
+
+		lastHop := routeHints[i][len(routeHints[i])-1]
+		idMatchesRefNode := bytes.Equal(
+			lastHop.NodeID.SerializeCompressed(),
+			refNodeID.SerializeCompressed(),
+		)
+		if !idMatchesRefNode {
+			return false
+		}
+	}
+
+	return true
+}
+
+// prepareLspRouteHints assumes that the isLsp heuristic returned true for the
+// route hints passed in here. It constructs a modified list of route hints that
+// allows the caller to probe the LSP, which itself is returned as a separate
+// hop hint.
+func prepareLspRouteHints(routeHints [][]zpay32.HopHint,
+	amt lnwire.MilliSatoshi) ([][]zpay32.HopHint, *zpay32.HopHint, error) {
+
+	if len(routeHints) == 0 {
+		return nil, nil, fmt.Errorf("no route hints provided")
+	}
+
+	// Create the LSP hop hint. We are probing for the worst case fee and
+	// cltv delta. So we look for the max values amongst all LSP hop hints.
+	refHint := routeHints[0][len(routeHints[0])-1]
+	refHint.CLTVExpiryDelta = maxLspCltvDelta(routeHints)
+	refHint.FeeBaseMSat, refHint.FeeProportionalMillionths = maxLspFee(
+		routeHints, amt,
+	)
+
+	// We construct a modified list of route hints that allows the caller to
+	// probe the LSP.
+	adjustedHints := make([][]zpay32.HopHint, 0, len(routeHints))
+
+	// Strip off the LSP hop hint from all route hints.
+	for i := 0; i < len(routeHints); i++ {
+		hint := routeHints[i]
+		if len(hint) > 1 {
+			adjustedHints = append(
+				adjustedHints, hint[:len(hint)-1],
+			)
+		}
+	}
+
+	return adjustedHints, &refHint, nil
+}
+
+// maxLspFee returns base fee and fee rate amongst all LSP route hints that
+// results in the overall highest fee for the given amount.
+func maxLspFee(routeHints [][]zpay32.HopHint, amt lnwire.MilliSatoshi) (uint32,
+	uint32) {
+
+	var maxFeePpm uint32
+	var maxBaseFee uint32
+	var maxTotalFee lnwire.MilliSatoshi
+	for _, rh := range routeHints {
+		lastHop := rh[len(rh)-1]
+		lastHopFee := lastHop.HopFee(amt)
+		if lastHopFee > maxTotalFee {
+			maxTotalFee = lastHopFee
+			maxBaseFee = lastHop.FeeBaseMSat
+			maxFeePpm = lastHop.FeeProportionalMillionths
+		}
+	}
+
+	return maxBaseFee, maxFeePpm
+}
+
+// maxLspCltvDelta returns the maximum cltv delta amongst all LSP route hints.
+func maxLspCltvDelta(routeHints [][]zpay32.HopHint) uint16 {
+	var maxCltvDelta uint16
+	for _, rh := range routeHints {
+		rhLastHop := rh[len(rh)-1]
+		if rhLastHop.CLTVExpiryDelta > maxCltvDelta {
+			maxCltvDelta = rhLastHop.CLTVExpiryDelta
+		}
+	}
+
+	return maxCltvDelta
+}
+
+// probePaymentStream is a custom implementation of the grpc.ServerStream
+// interface. It is used to send payment status updates to the caller on the
+// stream channel.
+type probePaymentStream struct {
+	Router_SendPaymentV2Server
+
+	stream chan *lnrpc.Payment
+	ctx    context.Context //nolint:containedctx
+}
+
+// Send sends a payment status update to a payment stream that the caller can
+// evaluate.
+func (p *probePaymentStream) Send(response *lnrpc.Payment) error {
+	select {
+	case p.stream <- response:
+
+	case <-p.ctx.Done():
+		return p.ctx.Err()
+	}
+
+	return nil
+}
+
+// Context returns the context of the stream.
+func (p *probePaymentStream) Context() context.Context {
+	return p.ctx
+}
+
+// sendProbePayment sends a payment to a target node in order to obtain
+// potential routing fees for it. The payment request has to contain a payment
+// hash that is guaranteed to be unknown to the target node, so it cannot settle
+// the payment. This method invokes a payment request loop in a goroutine and
+// awaits payment status updates.
+func (s *Server) sendProbePayment(ctx context.Context,
+	req *SendPaymentRequest) (*RouteFeeResponse, error) {
+
+	// We'll launch a goroutine to send the payment probes.
+	errChan := make(chan error, 1)
+	defer close(errChan)
+
+	paymentStream := &probePaymentStream{
+		stream: make(chan *lnrpc.Payment),
+		ctx:    ctx,
+	}
+	go func() {
+		err := s.SendPaymentV2(req, paymentStream)
+		if err != nil {
+			select {
+			case errChan <- err:
+
+			case <-paymentStream.ctx.Done():
+				return
+			}
+		}
+	}()
+
+	for {
+		select {
+		case payment := <-paymentStream.stream:
+			switch payment.Status {
+			case lnrpc.Payment_INITIATED:
+			case lnrpc.Payment_IN_FLIGHT:
+			case lnrpc.Payment_SUCCEEDED:
+				return nil, errors.New("warning, the fee " +
+					"estimation payment probe " +
+					"unexpectedly succeeded. Please reach" +
+					"out to the probe destination to " +
+					"negotiate a refund. Otherwise the " +
+					"payment probe amount is lost forever")
+
+			case lnrpc.Payment_FAILED:
+				// Incorrect payment details point to a
+				// successful probe.
+				//nolint:lll
+				if payment.FailureReason == lnrpc.PaymentFailureReason_FAILURE_REASON_INCORRECT_PAYMENT_DETAILS {
+					return paymentDetails(payment)
+				}
+
+				return &RouteFeeResponse{
+					RoutingFeeMsat: 0,
+					TimeLockDelay:  0,
+					FailureReason:  payment.FailureReason,
+				}, nil
+
+			default:
+				return nil, errors.New("unexpected payment " +
+					"status")
+			}
+
+		case err := <-errChan:
+			return nil, err
+
+		case <-s.quit:
+			return nil, errServerShuttingDown
+		}
+	}
+}
+
+func paymentDetails(payment *lnrpc.Payment) (*RouteFeeResponse, error) {
+	fee, timeLock, err := timelockAndFee(payment)
+	if errors.Is(err, errUnexpectedFailureSource) {
+		return nil, err
+	}
+
+	return &RouteFeeResponse{
+		RoutingFeeMsat: fee,
+		TimeLockDelay:  timeLock,
+		FailureReason:  lnrpc.PaymentFailureReason_FAILURE_REASON_NONE,
+	}, nil
+}
+
+// timelockAndFee returns the fee and total time lock of the last payment
+// attempt.
+func timelockAndFee(p *lnrpc.Payment) (int64, int64, error) {
+	if len(p.Htlcs) == 0 {
+		return 0, 0, nil
+	}
+
+	lastAttempt := p.Htlcs[len(p.Htlcs)-1]
+	if lastAttempt == nil {
+		return 0, 0, errMissingPaymentAttempt
+	}
+
+	lastRoute := lastAttempt.Route
+	if lastRoute == nil {
+		return 0, 0, errMissingRoute
+	}
+
+	hopFailureIndex := lastAttempt.Failure.FailureSourceIndex
+	finalHopIndex := uint32(len(lastRoute.Hops))
+	if hopFailureIndex != finalHopIndex {
+		return 0, 0, errUnexpectedFailureSource
+	}
+
+	return lastRoute.TotalFeesMsat, int64(lastRoute.TotalTimeLock), nil
+}
+
+// SendToRouteV2 sends a payment through a predefined route. The response of
+// this call contains structured error information.
 func (s *Server) SendToRouteV2(ctx context.Context,
 	req *SendToRouteRequest) (*lnrpc.HTLCAttempt, error) {
 
@@ -867,7 +1279,6 @@ func (s *Server) trackPayment(subscription routing.ControlTowerSubscriber,
 	identifier lntypes.Hash, stream Router_TrackPaymentV2Server,
 	noInflightUpdates bool) error {
 
-	// Stream updates to the client.
 	err := s.trackPaymentStream(
 		stream.Context(), subscription, noInflightUpdates, stream.Send,
 	)

lnrpc/routerrpc/router_server_test.go

@@ -5,10 +5,13 @@ import (
 	"testing"
 	"time"
 
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/lnrpc"
+	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/queue"
 	"github.com/lightningnetwork/lnd/routing"
+	"github.com/lightningnetwork/lnd/zpay32"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/grpc"
 )
@@ -214,3 +217,186 @@ func TestTrackPaymentsNoInflightUpdates(t *testing.T) {
 	payment := <-stream.sentFromServer
 	require.Equal(t, lnrpc.Payment_SUCCEEDED, payment.Status)
 }
+
+// TestIsLsp tests the isLSP heuristic. Combinations of different route hints
+// with different fees and cltv deltas are tested to ensure that the heuristic
+// correctly identifies whether a route leads to an LSP or not.
+func TestIsLsp(t *testing.T) {
+	probeAmtMsat := lnwire.MilliSatoshi(1_000_000)
+
+	alicePrivKey, err := btcec.NewPrivateKey()
+	require.NoError(t, err)
+	alicePubKey := alicePrivKey.PubKey()
+
+	bobPrivKey, err := btcec.NewPrivateKey()
+	require.NoError(t, err)
+	bobPubKey := bobPrivKey.PubKey()
+
+	carolPrivKey, err := btcec.NewPrivateKey()
+	require.NoError(t, err)
+	carolPubKey := carolPrivKey.PubKey()
+
+	davePrivKey, err := btcec.NewPrivateKey()
+	require.NoError(t, err)
+	davePubKey := davePrivKey.PubKey()
+
+	var (
+		aliceHopHint = zpay32.HopHint{
+			NodeID:                    alicePubKey,
+			FeeBaseMSat:               100,
+			FeeProportionalMillionths: 1_000,
+			ChannelID:                 421337,
+		}
+
+		bobHopHint = zpay32.HopHint{
+			NodeID:                    bobPubKey,
+			FeeBaseMSat:               2_000,
+			FeeProportionalMillionths: 2_000,
+			CLTVExpiryDelta:           288,
+			ChannelID:                 815,
+		}
+
+		carolHopHint = zpay32.HopHint{
+			NodeID:                    carolPubKey,
+			FeeBaseMSat:               2_000,
+			FeeProportionalMillionths: 2_000,
+			ChannelID:                 815,
+		}
+
+		daveHopHint = zpay32.HopHint{
+			NodeID:                    davePubKey,
+			FeeBaseMSat:               2_000,
+			FeeProportionalMillionths: 2_000,
+			ChannelID:                 815,
+		}
+	)
+
+	bobExpensiveCopy := bobHopHint.Copy()
+	bobExpensiveCopy.FeeBaseMSat = 1_000_000
+	bobExpensiveCopy.FeeProportionalMillionths = 1_000_000
+	bobExpensiveCopy.CLTVExpiryDelta = bobHopHint.CLTVExpiryDelta - 1
+
+	//nolint:lll
+	lspTestCases := []struct {
+		name           string
+		routeHints     [][]zpay32.HopHint
+		probeAmtMsat   lnwire.MilliSatoshi
+		isLsp          bool
+		expectedHints  [][]zpay32.HopHint
+		expectedLspHop *zpay32.HopHint
+	}{
+		{
+			name:           "empty route hints",
+			routeHints:     [][]zpay32.HopHint{{}},
+			probeAmtMsat:   probeAmtMsat,
+			isLsp:          false,
+			expectedHints:  [][]zpay32.HopHint{},
+			expectedLspHop: nil,
+		},
+		{
+			name:           "single route hint",
+			routeHints:     [][]zpay32.HopHint{{daveHopHint}},
+			probeAmtMsat:   probeAmtMsat,
+			isLsp:          true,
+			expectedHints:  [][]zpay32.HopHint{},
+			expectedLspHop: &daveHopHint,
+		},
+		{
+			name: "single route, multiple hints",
+			routeHints: [][]zpay32.HopHint{{
+				aliceHopHint, bobHopHint,
+			}},
+			probeAmtMsat:   probeAmtMsat,
+			isLsp:          true,
+			expectedHints:  [][]zpay32.HopHint{{aliceHopHint}},
+			expectedLspHop: &bobHopHint,
+		},
+		{
+			name: "multiple routes, multiple hints",
+			routeHints: [][]zpay32.HopHint{
+				{
+					aliceHopHint, bobHopHint,
+				},
+				{
+					carolHopHint, bobHopHint,
+				},
+			},
+			probeAmtMsat: probeAmtMsat,
+			isLsp:        true,
+			expectedHints: [][]zpay32.HopHint{
+				{aliceHopHint}, {carolHopHint},
+			},
+			expectedLspHop: &bobHopHint,
+		},
+		{
+			name: "multiple routes, multiple hints with min length",
+			routeHints: [][]zpay32.HopHint{
+				{
+					bobHopHint,
+				},
+				{
+					carolHopHint, bobHopHint,
+				},
+			},
+			probeAmtMsat: probeAmtMsat,
+			isLsp:        true,
+			expectedHints: [][]zpay32.HopHint{
+				{carolHopHint},
+			},
+			expectedLspHop: &bobHopHint,
+		},
+		{
+			name: "multiple routes, multiple hints, diff fees+cltv",
+			routeHints: [][]zpay32.HopHint{
+				{
+					bobHopHint,
+				},
+				{
+					carolHopHint, bobExpensiveCopy,
+				},
+			},
+			probeAmtMsat: probeAmtMsat,
+			isLsp:        true,
+			expectedHints: [][]zpay32.HopHint{
+				{carolHopHint},
+			},
+			expectedLspHop: &zpay32.HopHint{
+				NodeID:                    bobHopHint.NodeID,
+				ChannelID:                 bobHopHint.ChannelID,
+				FeeBaseMSat:               bobExpensiveCopy.FeeBaseMSat,
+				FeeProportionalMillionths: bobExpensiveCopy.FeeProportionalMillionths,
+				CLTVExpiryDelta:           bobHopHint.CLTVExpiryDelta,
+			},
+		},
+		{
+			name: "multiple routes, different final hops",
+			routeHints: [][]zpay32.HopHint{
+				{
+					aliceHopHint, bobHopHint,
+				},
+				{
+					carolHopHint, daveHopHint,
+				},
+			},
+			probeAmtMsat:   probeAmtMsat,
+			isLsp:          false,
+			expectedHints:  [][]zpay32.HopHint{},
+			expectedLspHop: nil,
+		},
+	}
+
+	for _, tc := range lspTestCases {
+		t.Run(tc.name, func(t *testing.T) {
+			require.Equal(t, tc.isLsp, isLSP(tc.routeHints))
+			if !tc.isLsp {
+				return
+			}
+
+			adjustedHints, lspHint, _ := prepareLspRouteHints(
+				tc.routeHints, tc.probeAmtMsat,
+			)
+			require.Equal(t, tc.expectedHints, adjustedHints)
+			require.Equal(t, tc.expectedLspHop, lspHint)
+		})
+	}
+}

lnrpc/routerrpc/routing_config.go

@@ -41,6 +41,9 @@ type RoutingConfig struct {
 
 	// BimodalConfig defines parameters for the bimodal probability.
 	BimodalConfig *BimodalConfig `group:"bimodal" namespace:"bimodal" description:"configuration for the bimodal pathfinding probability estimator"`
+
+	// FeeEstimationTimeout is the maximum time to wait for routing fees to be estimated.
+	FeeEstimationTimeout time.Duration `long:"fee-estimation-timeout" description:"the maximum time to wait for routing fees to be estimated by payment probes"`
 }
 
 // AprioriConfig defines parameters for the apriori probability.

lntest/harness.go

@@ -1614,8 +1614,8 @@ func (h *HarnessTest) mineTillForceCloseResolved(hn *node.HarnessNode) {
 // CreatePayReqs is a helper method that will create a slice of payment
 // requests for the given node.
 func (h *HarnessTest) CreatePayReqs(hn *node.HarnessNode,
-	paymentAmt btcutil.Amount, numInvoices int) ([]string,
-	[][]byte, []*lnrpc.Invoice) {
+	paymentAmt btcutil.Amount, numInvoices int,
+	routeHints ...*lnrpc.RouteHint) ([]string, [][]byte, []*lnrpc.Invoice) {
 
 	payReqs := make([]string, numInvoices)
 	rHashes := make([][]byte, numInvoices)
@@ -1624,9 +1624,10 @@ func (h *HarnessTest) CreatePayReqs(hn *node.HarnessNode,
 		preimage := h.Random32Bytes()
 
 		invoice := &lnrpc.Invoice{
-			Memo:      "testing",
-			RPreimage: preimage,
-			Value:     int64(paymentAmt),
+			Memo:       "testing",
+			RPreimage:  preimage,
+			Value:      int64(paymentAmt),
+			RouteHints: routeHints,
 		}
 		resp := hn.RPC.AddInvoice(invoice)
 

lntest/node/harness_node.go

@@ -876,6 +876,19 @@ func (hn *HarnessNode) RestoreDB() error {
 	return nil
 }
 
+// UpdateGlobalPolicy updates a node's global channel policy.
+func (hn *HarnessNode) UpdateGlobalPolicy(policy *lnrpc.RoutingPolicy) {
+	updateFeeReq := &lnrpc.PolicyUpdateRequest{
+		BaseFeeMsat: policy.FeeBaseMsat,
+		FeeRate: float64(policy.FeeRateMilliMsat) /
+			float64(1_000_000),
+		TimeLockDelta: policy.TimeLockDelta,
+		Scope:         &lnrpc.PolicyUpdateRequest_Global{Global: true},
+		MaxHtlcMsat:   policy.MaxHtlcMsat,
+	}
+	hn.RPC.UpdateChannelPolicy(updateFeeReq)
+}
+
 func postgresDatabaseDsn(dbName string) string {
 	return fmt.Sprintf(postgresDsn, dbName)
 }

routing/missioncontrol.go

@@ -62,6 +62,11 @@ const (
 	// have passed since the previously recorded failure before the failure
 	// amount may be raised.
 	DefaultMinFailureRelaxInterval = time.Minute
+
+	// DefaultFeeEstimationTimeout is the default value for
+	// FeeEstimationTimeout. It defines the maximum duration that the
+	// probing fee estimation is allowed to take.
+	DefaultFeeEstimationTimeout = time.Minute
 )
 
 var (

sample-lnd.conf

@@ -1205,6 +1205,9 @@
 ; `Payment_In_FLIGHT` will be sent for compatibility concerns.
 ; routerrpc.usestatusinitiated=false
 
+; Defines the the maximum duration that the probing fee estimation is allowed to
+; take.
+; routerrpc.fee-estimation-timeout=1m
 
 [workers]
 

zpay32/hophint.go

@@ -1,6 +1,9 @@
 package zpay32
 
-import "github.com/btcsuite/btcd/btcec/v2"
+import (
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/lightningnetwork/lnd/lnwire"
+)
 
 const (
 	// DefaultAssumedFinalCLTVDelta is the default value to be used as the
@@ -10,6 +13,9 @@ const (
 	// See also:
 	// https://github.com/lightning/bolts/blob/master/02-peer-protocol.md
 	DefaultAssumedFinalCLTVDelta = 18
+
+	// feeRateParts is the total number of parts used to express fee rates.
+	feeRateParts = 1e6
 )
 
 // HopHint is a routing hint that contains the minimum information of a channel
@@ -45,3 +51,13 @@ func (h HopHint) Copy() HopHint {
 		CLTVExpiryDelta:           h.CLTVExpiryDelta,
 	}
 }
+
+// HopFee calculates the fee for a given amount that is forwarded over a hop.
+// The amount has to be denoted in milli satoshi. The returned fee is also
+// denoted in milli satoshi.
+func (h HopHint) HopFee(amt lnwire.MilliSatoshi) lnwire.MilliSatoshi {
+	baseFee := lnwire.MilliSatoshi(h.FeeBaseMSat)
+	feeRate := lnwire.MilliSatoshi(h.FeeProportionalMillionths)
+
+	return baseFee + (amt*feeRate)/feeRateParts
+}