move should_channel_be_closed_due_to_expiring_htlcs into Channel class

electrum/lnchannel.py

@@ -1060,3 +1060,35 @@ class Channel(Logger):
         next_htlcs = self.hm.get_htlcs_in_next_ctx(subject)
         latest_htlcs = self.hm.get_htlcs_in_latest_ctx(subject)
         return not (next_htlcs == latest_htlcs and self.get_next_feerate(subject) == self.get_latest_feerate(subject))
+
+    def should_be_closed_due_to_expiring_htlcs(self, local_height) -> bool:
+        htlcs_we_could_reclaim = {}  # type: Dict[Tuple[Direction, int], UpdateAddHtlc]
+        # If there is a received HTLC for which we already released the preimage
+        # but the remote did not revoke yet, and the CLTV of this HTLC is dangerously close
+        # to the present, then unilaterally close channel
+        recv_htlc_deadline = lnutil.NBLOCK_DEADLINE_BEFORE_EXPIRY_FOR_RECEIVED_HTLCS
+        for sub, dir, ctn in ((LOCAL, RECEIVED, self.get_latest_ctn(LOCAL)),
+                              (REMOTE, SENT, self.get_oldest_unrevoked_ctn(LOCAL)),
+                              (REMOTE, SENT, self.get_latest_ctn(LOCAL)),):
+            for htlc_id, htlc in self.hm.htlcs_by_direction(subject=sub, direction=dir, ctn=ctn).items():
+                if not self.hm.was_htlc_preimage_released(htlc_id=htlc_id, htlc_sender=REMOTE):
+                    continue
+                if htlc.cltv_expiry - recv_htlc_deadline > local_height:
+                    continue
+                htlcs_we_could_reclaim[(RECEIVED, htlc_id)] = htlc
+        # If there is an offered HTLC which has already expired (+ some grace period after), we
+        # will unilaterally close the channel and time out the HTLC
+        offered_htlc_deadline = lnutil.NBLOCK_DEADLINE_AFTER_EXPIRY_FOR_OFFERED_HTLCS
+        for sub, dir, ctn in ((LOCAL, SENT, self.get_latest_ctn(LOCAL)),
+                              (REMOTE, RECEIVED, self.get_oldest_unrevoked_ctn(LOCAL)),
+                              (REMOTE, RECEIVED, self.get_latest_ctn(LOCAL)),):
+            for htlc_id, htlc in self.hm.htlcs_by_direction(subject=sub, direction=dir, ctn=ctn).items():
+                if htlc.cltv_expiry + offered_htlc_deadline > local_height:
+                    continue
+                htlcs_we_could_reclaim[(SENT, htlc_id)] = htlc
+
+        total_value_sat = sum([htlc.amount_msat // 1000 for htlc in htlcs_we_could_reclaim.values()])
+        num_htlcs = len(htlcs_we_could_reclaim)
+        min_value_worth_closing_channel_over_sat = max(num_htlcs * 10 * self.config[REMOTE].dust_limit_sat,
+                                                       500_000)
+        return total_value_sat > min_value_worth_closing_channel_over_sat

electrum/lnworker.py

@@ -725,7 +725,7 @@ class LNWallet(LNWorker):
 
     async def update_open_channel(self, chan, funding_txid, funding_height):
 
-        if chan.get_state() == channel_states.OPEN and self.should_channel_be_closed_due_to_expiring_htlcs(chan):
+        if chan.get_state() == channel_states.OPEN and chan.should_be_closed_due_to_expiring_htlcs(network.get_local_height()):
             self.logger.info(f"force-closing due to expiring htlcs")
             await self.try_force_closing(chan.channel_id)
             return
@@ -774,39 +774,6 @@ class LNWallet(LNWorker):
             chan.set_state(channel_states.REDEEMED)
 
 
-    def should_channel_be_closed_due_to_expiring_htlcs(self, chan: Channel) -> bool:
-        local_height = self.network.get_local_height()
-        htlcs_we_could_reclaim = {}  # type: Dict[Tuple[Direction, int], UpdateAddHtlc]
-        # If there is a received HTLC for which we already released the preimage
-        # but the remote did not revoke yet, and the CLTV of this HTLC is dangerously close
-        # to the present, then unilaterally close channel
-        recv_htlc_deadline = lnutil.NBLOCK_DEADLINE_BEFORE_EXPIRY_FOR_RECEIVED_HTLCS
-        for sub, dir, ctn in ((LOCAL, RECEIVED, chan.get_latest_ctn(LOCAL)),
-                              (REMOTE, SENT, chan.get_oldest_unrevoked_ctn(LOCAL)),
-                              (REMOTE, SENT, chan.get_latest_ctn(LOCAL)),):
-            for htlc_id, htlc in chan.hm.htlcs_by_direction(subject=sub, direction=dir, ctn=ctn).items():
-                if not chan.hm.was_htlc_preimage_released(htlc_id=htlc_id, htlc_sender=REMOTE):
-                    continue
-                if htlc.cltv_expiry - recv_htlc_deadline > local_height:
-                    continue
-                htlcs_we_could_reclaim[(RECEIVED, htlc_id)] = htlc
-        # If there is an offered HTLC which has already expired (+ some grace period after), we
-        # will unilaterally close the channel and time out the HTLC
-        offered_htlc_deadline = lnutil.NBLOCK_DEADLINE_AFTER_EXPIRY_FOR_OFFERED_HTLCS
-        for sub, dir, ctn in ((LOCAL, SENT, chan.get_latest_ctn(LOCAL)),
-                              (REMOTE, RECEIVED, chan.get_oldest_unrevoked_ctn(LOCAL)),
-                              (REMOTE, RECEIVED, chan.get_latest_ctn(LOCAL)),):
-            for htlc_id, htlc in chan.hm.htlcs_by_direction(subject=sub, direction=dir, ctn=ctn).items():
-                if htlc.cltv_expiry + offered_htlc_deadline > local_height:
-                    continue
-                htlcs_we_could_reclaim[(SENT, htlc_id)] = htlc
-
-        total_value_sat = sum([htlc.amount_msat // 1000 for htlc in htlcs_we_could_reclaim.values()])
-        num_htlcs = len(htlcs_we_could_reclaim)
-        min_value_worth_closing_channel_over_sat = max(num_htlcs * 10 * chan.config[REMOTE].dust_limit_sat,
-                                                       500_000)
-        return total_value_sat > min_value_worth_closing_channel_over_sat
-
     @log_exceptions
     async def _open_channel_coroutine(self, *, connect_str: str, funding_tx: PartialTransaction,
                                       funding_sat: int, push_sat: int,