fee_policy: instead of checking has_data, handle "eta_to_fee() is None"

Author: SomberNight

electrum/fee_policy.py

@@ -224,12 +224,12 @@ def fee_per_kb(self, network: 'Network') -> Optional[int]:
         if self.method == FeeMethod.FEERATE:
             fee_rate = self.value
         elif self.method == FeeMethod.MEMPOOL:
-            if network and network.mempool_fees.has_data():
+            if network:
                 fee_rate = network.mempool_fees.depth_to_fee(self.get_slider_pos())
             else:
                 fee_rate = None
         elif self.method == FeeMethod.ETA:
-            if network and network.fee_estimates.has_data():
+            if network:
                 fee_rate = network.fee_estimates.eta_to_fee(self.get_slider_pos())
             else:
                 fee_rate = None
@@ -372,8 +372,13 @@ def __init__(self):
     def get_data(self):
         return self.data
 
-    def has_data(self):
-        # we do not request estimate for next block fee
+    def has_data(self) -> bool:
+        """Returns if we have estimates for *all* targets requested.
+        Note: if wanting an estimate for a specific target, instead of checking has_data(),
+              just try to do the estimate and handle a potential None result. That way,
+              estimation works for targets we have, even if some targets are missing.
+        """
+        # we do not request estimate for next block fee, hence -1
         return len(self.data) == len(FEE_ETA_TARGETS) - 1
 
     def set_data(self, nblock_target: int, fee_per_kb: int):

electrum/lnworker.py

@@ -3072,28 +3072,27 @@ async def reestablish_peers_and_channels(self):
                     await self.taskgroup.spawn(self.reestablish_peer_for_given_channel(chan))
 
     def current_target_feerate_per_kw(self, *, has_anchors: bool) -> Optional[int]:
-        if self.network.fee_estimates.has_data():
-            target: int = FEE_LN_MINIMUM_ETA_TARGET if has_anchors else FEE_LN_ETA_TARGET
-            feerate_per_kvbyte = self.network.fee_estimates.eta_target_to_fee(target)
-            if has_anchors:
-                # set a floor of 5 sat/vb to have some safety margin in case the mempool
-                # grows quickly
-                feerate_per_kvbyte = max(feerate_per_kvbyte, 5000)
-        else:
+        target: int = FEE_LN_MINIMUM_ETA_TARGET if has_anchors else FEE_LN_ETA_TARGET
+        feerate_per_kvbyte = self.network.fee_estimates.eta_target_to_fee(target)
+        if feerate_per_kvbyte is None:
             if constants.net is constants.BitcoinRegtest:
                 feerate_per_kvbyte = FEERATE_REGTEST_STATIC_FEE
             else:
                 return None
+        if has_anchors:
+            # set a floor of 5 sat/vb to have some safety margin in case the mempool
+            # grows quickly
+            feerate_per_kvbyte = max(feerate_per_kvbyte, 5000)
         return max(FEERATE_PER_KW_MIN_RELAY_LIGHTNING, feerate_per_kvbyte // 4)
 
     def current_low_feerate_per_kw_srk_channel(self) -> Optional[int]:
         """Gets low feerate for static remote key channels."""
         if constants.net is constants.BitcoinRegtest:
             feerate_per_kvbyte = 0
         else:
-            if not self.network.fee_estimates.has_data():
+            feerate_per_kvbyte = self.network.fee_estimates.eta_target_to_fee(FEE_LN_LOW_ETA_TARGET)
+            if feerate_per_kvbyte is None:
                 return None
-            feerate_per_kvbyte = self.network.fee_estimates.eta_target_to_fee(FEE_LN_LOW_ETA_TARGET) or 0
         low_feerate_per_kw = max(FEERATE_PER_KW_MIN_RELAY_LIGHTNING, feerate_per_kvbyte // 4)
         # make sure this is never higher than the target feerate:
         current_target_feerate = self.current_target_feerate_per_kw(has_anchors=False)