From bbfeeec8b149e933ea0c28ff604c0d73a34b9fea Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Tue, 8 Sep 2020 13:02:33 +0200 Subject: [PATCH] routing: add proportional attempt cost --- lnrpc/routerrpc/config.go | 2 ++ lnrpc/routerrpc/routing_config.go | 8 ++++++- routing/pathfind.go | 36 ++++++++++++++++++++++++++----- routing/pathfind_test.go | 24 +++++++++++++++++---- sample-lnd.conf | 8 +++++-- server.go | 4 +++- 6 files changed, 69 insertions(+), 13 deletions(-) diff --git a/lnrpc/routerrpc/config.go b/lnrpc/routerrpc/config.go index 0782c685..1d1a6f8d 100644 --- a/lnrpc/routerrpc/config.go +++ b/lnrpc/routerrpc/config.go @@ -47,6 +47,7 @@ func DefaultConfig() *Config { MinRouteProbability: routing.DefaultMinRouteProbability, PenaltyHalfLife: routing.DefaultPenaltyHalfLife, AttemptCost: routing.DefaultAttemptCost.ToSatoshis(), + AttemptCostPPM: routing.DefaultAttemptCostPPM, MaxMcHistory: routing.DefaultMaxMcHistory, } @@ -62,6 +63,7 @@ func GetRoutingConfig(cfg *Config) *RoutingConfig { AprioriWeight: cfg.AprioriWeight, MinRouteProbability: cfg.MinRouteProbability, AttemptCost: cfg.AttemptCost, + AttemptCostPPM: cfg.AttemptCostPPM, PenaltyHalfLife: cfg.PenaltyHalfLife, MaxMcHistory: cfg.MaxMcHistory, } diff --git a/lnrpc/routerrpc/routing_config.go b/lnrpc/routerrpc/routing_config.go index a6fb2801..dd0fe93d 100644 --- a/lnrpc/routerrpc/routing_config.go +++ b/lnrpc/routerrpc/routing_config.go @@ -32,7 +32,13 @@ type RoutingConfig struct { // AttemptCost is the fixed virtual cost in path finding of a failed // payment attempt. It is used to trade off potentially better routes // against their probability of succeeding. - AttemptCost btcutil.Amount `long:"attemptcost" description:"The (virtual) cost in sats of a failed payment attempt"` + AttemptCost btcutil.Amount `long:"attemptcost" description:"The fixed (virtual) cost in sats of a failed payment attempt"` + + // AttemptCostPPM is the proportional virtual cost in path finding of a + // failed payment attempt. It is used to trade off potentially better + // routes against their probability of succeeding. This parameter is + // expressed in parts per million of the total payment amount. + AttemptCostPPM int64 `long:"attemptcostppm" description:"The proportional (virtual) cost in sats of a failed payment attempt expressed in parts per million of the total payment amount"` // MaxMcHistory defines the maximum number of payment results that // are held on disk by mission control. diff --git a/routing/pathfind.go b/routing/pathfind.go index 13c40072..cfc7afae 100644 --- a/routing/pathfind.go +++ b/routing/pathfind.go @@ -45,11 +45,23 @@ type pathFinder = func(g *graphParams, r *RestrictParams, []*channeldb.ChannelEdgePolicy, error) var ( - // DefaultAttemptCost is the default virtual cost in path finding of a - // failed payment attempt. It is used to trade off potentially better - // routes against their probability of succeeding. + // DefaultAttemptCost is the default fixed virtual cost in path finding + // of a failed payment attempt. It is used to trade off potentially + // better routes against their probability of succeeding. DefaultAttemptCost = lnwire.NewMSatFromSatoshis(100) + // DefaultAttemptCostPPM is the default proportional virtual cost in + // path finding weight units of executing a payment attempt that fails. + // It is used to trade off potentially better routes against their + // probability of succeeding. This parameter is expressed in parts per + // million of the payment amount. + // + // It is impossible to pick a perfect default value. The current value + // of 0.1% is based on the idea that a transaction fee of 1% is within + // reasonable territory and that a payment shouldn't need more than 10 + // attempts. + DefaultAttemptCostPPM = int64(1000) + // DefaultMinRouteProbability is the default minimum probability for routes // returned from findPath. DefaultMinRouteProbability = float64(0.01) @@ -314,11 +326,17 @@ type RestrictParams struct { // PathFindingConfig defines global parameters that control the trade-off in // path finding between fees and probabiity. type PathFindingConfig struct { - // AttemptCost is the virtual cost in path finding of a failed + // AttemptCost is the fixed virtual cost in path finding of a failed // payment attempt. It is used to trade off potentially better routes // against their probability of succeeding. AttemptCost lnwire.MilliSatoshi + // AttemptCostPPM is the proportional virtual cost in path finding of a + // failed payment attempt. It is used to trade off potentially better + // routes against their probability of succeeding. This parameter is + // expressed in parts per million of the total payment amount. + AttemptCostPPM int64 + // MinProbability defines the minimum success probability of the // returned route. MinProbability float64 @@ -548,6 +566,14 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig, // if the cltv limit is MaxUint32. absoluteCltvLimit := uint64(r.CltvLimit) + uint64(finalHtlcExpiry) + // Calculate the absolute attempt cost that is used for probability + // estimation. + absoluteAttemptCost := int64(cfg.AttemptCost) + + int64(amt)*cfg.AttemptCostPPM/1000000 + + log.Debugf("Pathfinding absolute attempt cost: %v sats", + float64(absoluteAttemptCost)/1000) + // processEdge is a helper closure that will be used to make sure edges // satisfy our specific requirements. processEdge := func(fromVertex route.Vertex, @@ -642,7 +668,7 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig, // probability. tempDist := getProbabilityBasedDist( tempWeight, probability, - int64(cfg.AttemptCost), + absoluteAttemptCost, ) // If there is already a best route stored, compare this diff --git a/routing/pathfind_test.go b/routing/pathfind_test.go index 76c0e68e..9c419403 100644 --- a/routing/pathfind_test.go +++ b/routing/pathfind_test.go @@ -2467,9 +2467,9 @@ func TestProbabilityRouting(t *testing.T) { // to the same total route probability. In both cases the three // hop route should be the best route. The three hop route has a // probability of 0.5 * 0.8 = 0.4. The fee is 5 (chan 10) + 8 - // (chan 11) = 13. Path finding distance should work out to: 13 - // + 10 (attempt penalty) / 0.4 = 38. The two hop route is 25 + - // 10 / 0.7 = 39. + // (chan 11) = 13. The attempt cost is 9 + 1% * 100 = 10. Path + // finding distance should work out to: 13 + 10 (attempt + // penalty) / 0.4 = 38. The two hop route is 25 + 10 / 0.7 = 39. { name: "three hop 1", p10: 0.8, p11: 0.5, p20: 0.7, @@ -2485,6 +2485,21 @@ func TestProbabilityRouting(t *testing.T) { amount: 100, }, + // If a larger amount is sent, the effect of the proportional + // attempt cost becomes more noticeable. This amount in this + // test brings the attempt cost to 9 + 1% * 300 = 12 sat. The + // three hop path finding distance should work out to: 13 + 12 + // (attempt penalty) / 0.4 = 43. The two hop route is 25 + 12 / + // 0.7 = 42. For this higher amount, the two hop route is + // expected to be selected. + { + name: "two hop high amount", + p10: 0.8, p11: 0.5, p20: 0.7, + minProbability: 0.1, + expectedChan: 20, + amount: 300, + }, + // If the probability of the two hop route is increased, its // distance becomes 25 + 10 / 0.85 = 37. This is less than the // three hop route with its distance 38. So with an attempt @@ -2589,7 +2604,8 @@ func testProbabilityRouting(t *testing.T, paymentAmt btcutil.Amount, } ctx.pathFindingConfig = PathFindingConfig{ - AttemptCost: lnwire.NewMSatFromSatoshis(10), + AttemptCost: lnwire.NewMSatFromSatoshis(9), + AttemptCostPPM: 10000, MinProbability: minProbability, } diff --git a/sample-lnd.conf b/sample-lnd.conf index b92f8b76..873a6d6d 100644 --- a/sample-lnd.conf +++ b/sample-lnd.conf @@ -619,8 +619,12 @@ litecoin.node=ltcd ; probability (default: 1h0m0s) ; routerrpc.penaltyhalflife=2h -; The (virtual) cost in sats of a failed payment attempt (default: 100) -; routerrpc.attemptcost=90 +; The (virtual) fixed cost in sats of a failed payment attempt (default: 100) +; routerrpc.attemptcost=90 + +; The (virtual) proportional cost in ppm of the total amount of a failed payment +; attempt (default: 1000) +; routerrpc.attemptcostppm=900 ; The maximum number of payment results that are held on disk by mission control ; (default: 1000) diff --git a/server.go b/server.go index f2308db8..9fb89aef 100644 --- a/server.go +++ b/server.go @@ -724,14 +724,16 @@ func newServer(cfg *Config, listenAddrs []net.Addr, } srvrLog.Debugf("Instantiating payment session source with config: "+ - "AttemptCost=%v, MinRouteProbability=%v", + "AttemptCost=%v + %v%%, MinRouteProbability=%v", int64(routingConfig.AttemptCost), + float64(routingConfig.AttemptCostPPM)/10000, routingConfig.MinRouteProbability) pathFindingConfig := routing.PathFindingConfig{ AttemptCost: lnwire.NewMSatFromSatoshis( routingConfig.AttemptCost, ), + AttemptCostPPM: routingConfig.AttemptCostPPM, MinProbability: routingConfig.MinRouteProbability, }