Add success probabilities in path finding (#1942)

Add an alternative heuristic for path finding that combines the relay fees with virtual fees for hops, funds locked and failed payments.

Author: thomash-acinq

docs/release-notes/eclair-vnext.md

@@ -127,6 +127,7 @@ This release contains many API updates:
 - `payinvoice`, `sendtonode`, `findroute`, `findroutetonode` and `findroutebetweennodes` let you specify `--pathFindingExperimentName` when using path-finding A/B testing (#1930)
 - the `--maxFeePct` parameter used in `payinvoice` and `sendtonode` must now be an integer between 0 and 100: it was previously a value between 0 and 1, which was misleading for a percentage (#1930)
 - `findroute`, `findroutetonode` and `findroutebetweennodes` let you choose the format of the route returned with the `--routeFormat` parameter (supported values are `nodeId` and `shortChannelId`) (#1943)
+- `findroute`, `findroutetonode` and `findroutebetweennodes` now accept `--includeLocalChannelCost` to specify if you want to count the fees from your node like trampoline payments do (#1942) 
 
 Have a look at our [API documentation](https://acinq.github.io/eclair) for more details.
 

eclair-core/src/main/resources/reference.conf

@@ -215,6 +215,7 @@ eclair {
           channel-age = 0.4       // when computing the weight for a channel, consider its AGE in this proportion
           channel-capacity = 0.55 // when computing the weight for a channel, consider its CAPACITY in this proportion
         }
+        use-ratios = true
 
         // Virtual fee for additional hops
         // Corresponds to how much you are willing to pay to get one less hop in the payment path
@@ -240,6 +241,21 @@ eclair {
           percentage = 100 // 100% of the traffic use the default configuration
         }
 
+        // alternative routing heuristics (replaces ratios)
+        test-failure-cost = ${eclair.router.path-finding.default} {
+          use-ratios = false
+
+          locked-funds-risk = 1e-8 // msat per msat locked per block. It should be your expected interest rate per block multiplied by the probability that something goes wrong and your funds stay locked.
+          // 1e-8 corresponds to an interest rate of ~5% per year (1e-6 per block) and a probability of 1% that the channel will fail and our funds will be locked.
+
+          // Virtual fee for failed payments
+          // Corresponds to how much you are willing to pay to get one less failed payment attempt
+          failure-cost {
+            fee-base-msat = 2000
+            fee-proportional-millionths = 500
+          }
+        }
+
         // Examples of other configs as 0% experiments:
 
         // To optimize for fees only:

eclair-core/src/main/scala/fr/acinq/eclair/Eclair.scala

@@ -122,9 +122,9 @@ trait Eclair {
 
   def sendOnChain(address: String, amount: Satoshi, confirmationTarget: Long): Future[ByteVector32]
 
-  def findRoute(targetNodeId: PublicKey, amount: MilliSatoshi, pathFindingExperimentName_opt: Option[String], assistedRoutes: Seq[Seq[PaymentRequest.ExtraHop]] = Seq.empty)(implicit timeout: Timeout): Future[RouteResponse]
+  def findRoute(targetNodeId: PublicKey, amount: MilliSatoshi, pathFindingExperimentName_opt: Option[String], assistedRoutes: Seq[Seq[PaymentRequest.ExtraHop]] = Seq.empty, includeLocalChannelCost: Boolean = false)(implicit timeout: Timeout): Future[RouteResponse]
 
-  def findRouteBetween(sourceNodeId: PublicKey, targetNodeId: PublicKey, amount: MilliSatoshi, pathFindingExperimentName_opt: Option[String], assistedRoutes: Seq[Seq[PaymentRequest.ExtraHop]] = Seq.empty)(implicit timeout: Timeout): Future[RouteResponse]
+  def findRouteBetween(sourceNodeId: PublicKey, targetNodeId: PublicKey, amount: MilliSatoshi, pathFindingExperimentName_opt: Option[String], assistedRoutes: Seq[Seq[PaymentRequest.ExtraHop]] = Seq.empty, includeLocalChannelCost: Boolean = false)(implicit timeout: Timeout): Future[RouteResponse]
 
   def sendToRoute(amount: MilliSatoshi, recipientAmount_opt: Option[MilliSatoshi], externalId_opt: Option[String], parentId_opt: Option[UUID], invoice: PaymentRequest, finalCltvExpiryDelta: CltvExpiryDelta, route: PredefinedRoute, trampolineSecret_opt: Option[ByteVector32] = None, trampolineFees_opt: Option[MilliSatoshi] = None, trampolineExpiryDelta_opt: Option[CltvExpiryDelta] = None, trampolineNodes_opt: Seq[PublicKey] = Nil)(implicit timeout: Timeout): Future[SendPaymentToRouteResponse]
 
@@ -279,8 +279,8 @@ class EclairImpl(appKit: Kit) extends Eclair with Logging {
     }
   }
 
-  override def findRoute(targetNodeId: PublicKey, amount: MilliSatoshi, pathFindingExperimentName_opt: Option[String], assistedRoutes: Seq[Seq[PaymentRequest.ExtraHop]] = Seq.empty)(implicit timeout: Timeout): Future[RouteResponse] =
-    findRouteBetween(appKit.nodeParams.nodeId, targetNodeId, amount, pathFindingExperimentName_opt, assistedRoutes)
+  override def findRoute(targetNodeId: PublicKey, amount: MilliSatoshi, pathFindingExperimentName_opt: Option[String], assistedRoutes: Seq[Seq[PaymentRequest.ExtraHop]] = Seq.empty, includeLocalChannelCost: Boolean = false)(implicit timeout: Timeout): Future[RouteResponse] =
+    findRouteBetween(appKit.nodeParams.nodeId, targetNodeId, amount, pathFindingExperimentName_opt, assistedRoutes, includeLocalChannelCost)
 
   private def getRouteParams(pathFindingExperimentName_opt: Option[String]): Option[RouteParams] = {
     pathFindingExperimentName_opt match {
@@ -289,11 +289,11 @@ class EclairImpl(appKit: Kit) extends Eclair with Logging {
     }
   }
 
-  override def findRouteBetween(sourceNodeId: PublicKey, targetNodeId: PublicKey, amount: MilliSatoshi, pathFindingExperimentName_opt: Option[String], assistedRoutes: Seq[Seq[PaymentRequest.ExtraHop]] = Seq.empty)(implicit timeout: Timeout): Future[RouteResponse] = {
+  override def findRouteBetween(sourceNodeId: PublicKey, targetNodeId: PublicKey, amount: MilliSatoshi, pathFindingExperimentName_opt: Option[String], assistedRoutes: Seq[Seq[PaymentRequest.ExtraHop]] = Seq.empty, includeLocalChannelCost: Boolean = false)(implicit timeout: Timeout): Future[RouteResponse] = {
     getRouteParams(pathFindingExperimentName_opt) match {
       case Some(routeParams) =>
         val maxFee = routeParams.getMaxFee(amount)
-        (appKit.router ? RouteRequest(sourceNodeId, targetNodeId, amount, maxFee, assistedRoutes, routeParams = routeParams)).mapTo[RouteResponse]
+        (appKit.router ? RouteRequest(sourceNodeId, targetNodeId, amount, maxFee, assistedRoutes, routeParams = routeParams.copy(includeLocalChannelCost = includeLocalChannelCost))).mapTo[RouteResponse]
       case None => Future.failed(new IllegalArgumentException(s"Path-finding experiment ${pathFindingExperimentName_opt.get} does not exist."))
     }
   }

eclair-core/src/main/scala/fr/acinq/eclair/NodeParams.scala

@@ -27,7 +27,7 @@ import fr.acinq.eclair.crypto.keymanager.{ChannelKeyManager, NodeKeyManager}
 import fr.acinq.eclair.db._
 import fr.acinq.eclair.io.PeerConnection
 import fr.acinq.eclair.payment.relay.Relayer.{RelayFees, RelayParams}
-import fr.acinq.eclair.router.Graph.WeightRatios
+import fr.acinq.eclair.router.Graph.{HeuristicsConstants, WeightRatios}
 import fr.acinq.eclair.router.PathFindingExperimentConf
 import fr.acinq.eclair.router.Router.{MultiPartParams, PathFindingConf, RouterConf, SearchBoundaries}
 import fr.acinq.eclair.tor.Socks5ProxyParams
@@ -327,13 +327,21 @@ object NodeParams extends Logging {
         maxCltv = CltvExpiryDelta(config.getInt("boundaries.max-cltv")),
         maxFeeFlat = Satoshi(config.getLong("boundaries.max-fee-flat-sat")).toMilliSatoshi,
         maxFeeProportional = config.getDouble("boundaries.max-fee-proportional-percent") / 100.0),
-      ratios = WeightRatios(
-        baseFactor = config.getDouble("ratios.base"),
-        cltvDeltaFactor = config.getDouble("ratios.cltv"),
-        ageFactor = config.getDouble("ratios.channel-age"),
-        capacityFactor = config.getDouble("ratios.channel-capacity"),
-        hopCost = getRelayFees(config.getConfig("hop-cost")),
-      ),
+      heuristicsParams = if (config.getBoolean("use-ratios")) {
+        Left(WeightRatios(
+          baseFactor = config.getDouble("ratios.base"),
+          cltvDeltaFactor = config.getDouble("ratios.cltv"),
+          ageFactor = config.getDouble("ratios.channel-age"),
+          capacityFactor = config.getDouble("ratios.channel-capacity"),
+          hopCost = getRelayFees(config.getConfig("hop-cost")),
+        ))
+      } else {
+        Right(HeuristicsConstants(
+          lockedFundsRisk = config.getDouble("locked-funds-risk"),
+          failureCost = getRelayFees(config.getConfig("failure-cost")),
+          hopCost = getRelayFees(config.getConfig("hop-cost")),
+        ))
+      },
       mpp = MultiPartParams(
         Satoshi(config.getLong("mpp.min-amount-satoshis")).toMilliSatoshi,
         config.getInt("mpp.max-parts")),

eclair-core/src/main/scala/fr/acinq/eclair/remote/EclairInternalsSerializer.scala

@@ -24,8 +24,8 @@ import fr.acinq.eclair.io.Peer.PeerRoutingMessage
 import fr.acinq.eclair.io.Switchboard.RouterPeerConf
 import fr.acinq.eclair.io.{ClientSpawner, Peer, PeerConnection, Switchboard}
 import fr.acinq.eclair.payment.relay.Relayer.RelayFees
-import fr.acinq.eclair.router.Graph.WeightRatios
-import fr.acinq.eclair.router.Router.{GossipDecision, MultiPartParams, PathFindingConf, RouteParams, RouterConf, SearchBoundaries, SendChannelQuery}
+import fr.acinq.eclair.router.Graph.{HeuristicsConstants, WeightRatios}
+import fr.acinq.eclair.router.Router.{GossipDecision, MultiPartParams, PathFindingConf, RouterConf, SearchBoundaries, SendChannelQuery}
 import fr.acinq.eclair.router._
 import fr.acinq.eclair.wire.protocol.CommonCodecs._
 import fr.acinq.eclair.wire.protocol.LightningMessageCodecs._
@@ -50,9 +50,9 @@ object EclairInternalsSerializer {
 
   val searchBoundariesCodec: Codec[SearchBoundaries] = (
     ("maxFee" | millisatoshi) ::
-    ("maxFeeProportional" | double) ::
-    ("maxRouteLength" | int32) ::
-    ("maxCltv" | int32.as[CltvExpiryDelta])).as[SearchBoundaries]
+      ("maxFeeProportional" | double) ::
+      ("maxRouteLength" | int32) ::
+      ("maxCltv" | int32.as[CltvExpiryDelta])).as[SearchBoundaries]
 
   val relayFeesCodec: Codec[RelayFees] = (
     ("feeBase" | millisatoshi) ::
@@ -65,14 +65,19 @@ object EclairInternalsSerializer {
       ("capacityFactor" | double) ::
       ("hopCost" | relayFeesCodec)).as[WeightRatios]
 
+  val heuristicsConstantsCodec: Codec[HeuristicsConstants] = (
+    ("lockedFundsRisk" | double) ::
+      ("failureCost" | relayFeesCodec) ::
+      ("hopCost" | relayFeesCodec)).as[HeuristicsConstants]
+
   val multiPartParamsCodec: Codec[MultiPartParams] = (
     ("minPartAmount" | millisatoshi) ::
       ("maxParts" | int32)).as[MultiPartParams]
 
   val pathFindingConfCodec: Codec[PathFindingConf] = (
     ("randomize" | bool(8)) ::
       ("boundaries" | searchBoundariesCodec) ::
-      ("ratios" | weightRatiosCodec) ::
+      ("heuristicsParams" | either(bool(8), weightRatiosCodec, heuristicsConstantsCodec)) ::
       ("mpp" | multiPartParamsCodec) ::
       ("experimentName" | utf8_32) ::
       ("experimentPercentage" | int32)).as[PathFindingConf]