Add new heuristics in addition to weight ratios

Author: thomash-acinq

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

@@ -219,8 +219,10 @@ eclair {
 
         // Virtual fee for additional hops
         // Corresponds to how much you are willing to pay to get one less hop in the payment path
-        hop-cost-base-msat = 500
-        hop-cost-millionths = 200
+        hop-cost {
+          fee-base-msat = 500
+          fee-proportional-millionths = 200
+        }
 
         mpp {
           min-amount-satoshis = 15000 // minimum amount sent via partial HTLCs
@@ -235,6 +237,18 @@ eclair {
           percentage = 100 // All traffic use the default configuration
         }
 
+        // alternative routing heuristics (replaces ratios)
+        test-failure-cost = ${eclair.router.path-finding.default} {
+          locked-funds-risk = 1e-15 // 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.
+
+          // 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/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
@@ -210,8 +210,8 @@ object NodeParams extends Logging {
       "router.path-finding.ratio-cltv" -> "router.path-finding.default.ratios.cltv",
       "router.path-finding.ratio-channel-age" -> "router.path-finding.default.ratios.channel-age",
       "router.path-finding.ratio-channel-capacity" -> "router.path-finding.default.ratios.channel-capacity",
-      "router.path-finding.hop-cost-base-msat" -> "router.path-finding.default.hop-cost-base-msat",
-      "router.path-finding.hop-cost-millionths" -> "router.path-finding.default.hop-cost-millionths",
+      "router.path-finding.hop-cost-base-msat" -> "router.path-finding.default.hop-cost.fee-base-msat",
+      "router.path-finding.hop-cost-millionths" -> "router.path-finding.default.hop-cost.fee-proportional-millionths",
     )
     deprecatedKeyPaths.foreach {
       case (old, new_) => require(!config.hasPath(old), s"configuration key '$old' has been replaced by '$new_'")
@@ -317,6 +317,18 @@ object NodeParams extends Logging {
       RelayFees(feeBase, relayFeesConfig.getInt("fee-proportional-millionths"))
     }
 
+    def getHeuristicsConstants(config: Config): Option[HeuristicsConstants] = {
+      if (config.hasPath("locked-funds-risk") || config.hasPath("failure-cost")) {
+        Some(HeuristicsConstants(
+          lockedFundsRisk = config.getDouble("locked-funds-risk"),
+          failureCost = getRelayFees(config.getConfig("failure-cost")),
+          hopCost = getRelayFees(config.getConfig("hop-cost")),
+        ))
+      } else {
+        None
+      }
+    }
+
     def getPathFindingConf(config: Config, name: String): PathFindingConf = PathFindingConf(
       randomize = config.getBoolean("randomize-route-selection"),
       boundaries = SearchBoundaries(
@@ -329,9 +341,9 @@ object NodeParams extends Logging {
         cltvDeltaFactor = config.getDouble("ratios.cltv"),
         ageFactor = config.getDouble("ratios.channel-age"),
         capacityFactor = config.getDouble("ratios.channel-capacity"),
-        hopCostBase = MilliSatoshi(config.getLong("hop-cost-base-msat")),
-        hopCostMillionths = config.getLong("hop-cost-millionths")
+        hopCost = getRelayFees(config.getConfig("hop-cost")),
       ),
+      heuristicsConstants_opt = getHeuristicsConstants(config),
       mpp = MultiPartParams(
         Satoshi(config.getLong("mpp.min-amount-satoshis")).toMilliSatoshi,
         config.getInt("mpp.max-parts")),

eclair-core/src/main/scala/fr/acinq/eclair/payment/relay/Relayer.scala

@@ -112,7 +112,10 @@ object Relayer extends Logging {
     Props(new Relayer(nodeParams, router, register, paymentHandler, initialized))
 
   // @formatter:off
-  case class RelayFees(feeBase: MilliSatoshi, feeProportionalMillionths: Long)
+  case class RelayFees(feeBase: MilliSatoshi, feeProportionalMillionths: Long) {
+    require(feeBase.toLong >= 0.0, "feeBase must be nonnegative")
+    require(feeProportionalMillionths >= 0.0, "feeProportionalMillionths must be nonnegative")
+  }
 
   case class RelayParams(publicChannelFees: RelayFees,
                          privateChannelFees: RelayFees,

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

@@ -23,8 +23,9 @@ import fr.acinq.eclair.crypto.TransportHandler
 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.router.Graph.WeightRatios
-import fr.acinq.eclair.router.Router.{GossipDecision, MultiPartParams, PathFindingConf, RouteParams, RouterConf, SearchBoundaries, SendChannelQuery}
+import fr.acinq.eclair.payment.relay.Relayer.RelayFees
+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._
@@ -49,17 +50,20 @@ 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) ::
+      ("feeProportionalMillionths" | int64)).as[RelayFees]
 
   val weightRatiosCodec: Codec[WeightRatios] = (
     ("baseFactor" | double) ::
       ("cltvDeltaFactor" | double) ::
       ("ageFactor" | double) ::
       ("capacityFactor" | double) ::
-      ("hopCostBase" | millisatoshi) ::
-      ("hopCostMillionths" | int64)).as[WeightRatios]
+      ("hopCost" | relayFeesCodec)).as[WeightRatios]
 
   val multiPartParamsCodec: Codec[MultiPartParams] = (
     ("minPartAmount" | millisatoshi) ::
@@ -69,6 +73,7 @@ object EclairInternalsSerializer {
     ("randomize" | bool(8)) ::
       ("boundaries" | searchBoundariesCodec) ::
       ("ratios" | weightRatiosCodec) ::
+      ("heuristicsConstants_opt" | provide[Option[HeuristicsConstants]](None)) ::
       ("mpp" | multiPartParamsCodec) ::
       ("experimentName" | utf8_32) ::
       ("experimentPercentage" | int32)).as[PathFindingConf]