Improve JIT channel opening

Author: f321x

electrum/lnpeer.py

@@ -393,7 +393,9 @@ def on_init(self, payload):
         if their_networks:
             their_chains = list(chunks(their_networks["chains"], 32))
             if constants.net.rev_genesis_bytes() not in their_chains:
-                raise GracefulDisconnect(f"no common chain found with remote. (they sent: {their_chains})")
+                raise GracefulDisconnect(f"no common chain found with remote. "
+                                         f"(they sent: {[chain.hex() for chain in their_chains]}),"
+                                         f" our chain: {constants.net.rev_genesis_bytes().hex()}")
         # all checks passed
         self.lnworker.on_peer_successfully_established(self)
         self._received_init = True
@@ -967,7 +969,7 @@ async def channel_establishment_flow(
             public: bool,
             zeroconf: bool = False,
             temp_channel_id: bytes,
-            opening_fee: int = None,
+            opening_fee_msat: int = None,
     ) -> Tuple[Channel, 'PartialTransaction']:
         """Implements the channel opening flow.
 
@@ -1026,10 +1028,10 @@ async def channel_establishment_flow(
         open_channel_tlvs['upfront_shutdown_script'] = {
             'shutdown_scriptpubkey': local_config.upfront_shutdown_script
         }
-        if opening_fee:
+        if opening_fee_msat:
             # todo: maybe add payment hash
             open_channel_tlvs['channel_opening_fee'] = {
-                'channel_opening_fee': opening_fee
+                'channel_opening_fee': opening_fee_msat
             }
         # for the first commitment transaction
         per_commitment_secret_first = get_per_commitment_secret_from_seed(
@@ -1258,10 +1260,10 @@ async def on_open_channel(self, payload):
         # store the temp id now, so that it is recognized for e.g. 'error' messages
         # TODO: this is never cleaned up; the dict grows unbounded until disconnect
         self.temp_id_to_id[temp_chan_id] = None
-        channel_opening_fee = open_channel_tlvs.get('channel_opening_fee') if open_channel_tlvs else None
-        if channel_opening_fee:
-            # todo check that the fee is reasonable
-            pass
+        channel_opening_fee_msat = open_channel_tlvs.get('channel_opening_fee') if open_channel_tlvs else None
+        if channel_opening_fee_msat:
+            if channel_opening_fee_msat // 1000 > funding_sat * 0.1:
+                raise Exception(f"Channel opening fee is too expensive, rejecting channel")
 
         if self.use_anchors():
             multisig_funding_keypair = lnutil.derive_multisig_funding_key_if_they_opened(
@@ -1375,7 +1377,7 @@ async def on_open_channel(self, payload):
             chan_dict,
             lnworker=self.lnworker,
             initial_feerate=feerate,
-            opening_fee = channel_opening_fee,
+            opening_fee = channel_opening_fee_msat,
         )
         chan.storage['init_timestamp'] = int(time.time())
         if isinstance(self.transport, LNTransport):
@@ -2221,7 +2223,7 @@ async def maybe_forward_trampoline(
 
         # do we have a connection to the node?
         next_peer = self.lnworker.peers.get(outgoing_node_id)
-        if next_peer and next_peer.accepts_zeroconf():
+        if next_peer and next_peer.accepts_zeroconf() and self.lnworker.features.supports(LnFeatures.OPTION_ZEROCONF_OPT):
             self.logger.info(f'JIT: found next_peer')
             for next_chan in next_peer.channels.values():
                 if next_chan.can_pay(amt_to_forward):
@@ -2484,6 +2486,7 @@ def log_fail_reason(reason: str):
             raise exc_incorrect_or_unknown_pd
         invoice_msat = info.amount_msat
         if channel_opening_fee:
+            # TODO: we should remove the fee once paid?
             invoice_msat -= channel_opening_fee
 
         if not (invoice_msat is None or invoice_msat <= total_msat <= 2 * invoice_msat):

electrum/lnutil.py

@@ -1706,6 +1706,7 @@ def list_enabled_ln_feature_bits(features: int) -> tuple[int, ...]:
     return tuple(sorted(single_feature_bits))
 
 
+class FeeTooLow(Exception): pass
 class IncompatibleOrInsaneFeatures(Exception): pass
 class UnknownEvenFeatureBits(IncompatibleOrInsaneFeatures): pass
 class IncompatibleLightningFeatures(IncompatibleOrInsaneFeatures): pass

electrum/lnwatcher.py

@@ -65,7 +65,7 @@ def add_channel(self, outpoint: str, address: str) -> None:
         cb = lambda: self.check_onchain_situation(address, outpoint)
         self.add_callback(address, cb)
 
-    async def unwatch_channel(self, address, funding_outpoint):
+    def unwatch_channel(self, address, funding_outpoint):
         self.logger.info(f'unwatching {funding_outpoint}')
         self.remove_callback(address)
 
@@ -128,7 +128,7 @@ async def check_onchain_situation(self, address, funding_outpoint):
             closing_height=closing_height,
             keep_watching=keep_watching)
         if not keep_watching:
-            await self.unwatch_channel(address, funding_outpoint)
+            self.unwatch_channel(address, funding_outpoint)
 
     async def sweep_commitment_transaction(self, funding_outpoint: str, closing_tx: Transaction) -> bool:
         raise NotImplementedError()  # implemented by subclasses

electrum/lnworker.py

@@ -62,7 +62,7 @@
     LnKeyFamily, LOCAL, REMOTE, MIN_FINAL_CLTV_DELTA_FOR_INVOICE, SENT, RECEIVED, HTLCOwner, UpdateAddHtlc, LnFeatures,
     ShortChannelID, HtlcLog, NoPathFound, InvalidGossipMsg, FeeBudgetExceeded, ImportedChannelBackupStorage,
     OnchainChannelBackupStorage, ln_compare_features, IncompatibleLightningFeatures, PaymentFeeBudget,
-    NBLOCK_CLTV_DELTA_TOO_FAR_INTO_FUTURE, GossipForwardingMessage
+    NBLOCK_CLTV_DELTA_TOO_FAR_INTO_FUTURE, GossipForwardingMessage, ZEROCONF_TIMEOUT, FeeTooLow
 )
 from .lnonion import decode_onion_error, OnionFailureCode, OnionRoutingFailure, OnionPacket
 from .lnmsg import decode_msg
@@ -76,6 +76,7 @@
     create_trampoline_route_and_onion, is_legacy_relay, trampolines_by_id, hardcoded_trampoline_nodes,
     is_hardcoded_trampoline
 )
+from .network import TxBroadcastServerReturnedError
 
 if TYPE_CHECKING:
     from .network import Network
@@ -892,6 +893,10 @@ def __init__(self, wallet: 'Abstract_Wallet', xprv):
         self.swap_manager = SwapManager(wallet=self.wallet, lnworker=self)
         self.onion_message_manager = OnionMessageManager(self)
 
+        # to keep track of the channels we sold as just-in-time provider
+        if self.config.ACCEPT_ZEROCONF_CHANNELS:
+            self.sold_just_in_time_channels = self.db.get_dict('sold_just_in_time_channels')  # type: Dict[str, int]  # channel_id -> revenue sat (opening fee - funding tx fee)
+
     def has_deterministic_node_id(self) -> bool:
         return bool(self.db.get('lightning_xprv'))
 
@@ -1129,7 +1134,7 @@ def get_lightning_history(self) -> Dict[str, LightningHistoryItem]:
         balance_msat = sum([x.amount_msat for x in out.values()])
         lb = sum(chan.balance(LOCAL) if not chan.is_closed_or_closing() else 0
                 for chan in self.channels.values())
-        assert balance_msat  == lb
+        assert balance_msat  == lb, f"balance_msat: {balance_msat} != lb: {lb}"
         return out
 
     def get_groups_for_onchain_history(self) -> Dict[str, str]:
@@ -1235,7 +1240,6 @@ def _scid_alias_of_node(self, nodeid: bytes) -> bytes:
     def get_static_jit_scid_alias(self) -> bytes:
         return self._scid_alias_of_node(self.node_keypair.pubkey)
 
-    @log_exceptions
     async def open_channel_just_in_time(
         self,
         *,
@@ -1244,36 +1248,69 @@ async def open_channel_just_in_time(
         next_cltv_abs: int,
         payment_hash: bytes,
         next_onion: OnionPacket,
-    ) -> str:
+    ) -> Optional[str]:
+        """Wrapper around __open_channel_just_in_time to allow for cleaner htlc locking and preimage deletion"""
+
+        # prevent settling the htlc until the channel opening was successfully so we can fail it if needed
+        self.dont_settle_htlcs[payment_hash.hex()] = None
+        try:
+            return await self.__open_channel_just_in_time(
+                next_peer=next_peer,
+                next_amount_msat_htlc=next_amount_msat_htlc,
+                next_cltv_abs=next_cltv_abs,
+                payment_hash=payment_hash,
+                next_onion=next_onion,
+            )
+        except Exception:
+            self.logger.warning(f"failed to open jit channel", exc_info=True)
+            # ensure that we not accidentally store a preimage on exception
+            self.preimages.pop(payment_hash.hex(), None)
+            raise
+        finally:
+            del self.dont_settle_htlcs[payment_hash.hex()]
+
+    @log_exceptions
+    async def __open_channel_just_in_time(
+        self,
+        *,
+        next_peer: Peer,
+        next_amount_msat_htlc: int,
+        next_cltv_abs: int,
+        payment_hash: bytes,
+        next_onion: OnionPacket,
+    ) -> Optional[str]:
         # if an exception is raised during negotiation, we raise an OnionRoutingFailure.
         # this will cancel the incoming HTLC
+        assert self.config.ZEROCONF_RELATIVE_OPENING_FEE_PPM > 0, self.config.ZEROCONF_MIN_OPENING_FEE_SAT > 0
 
-        # prevent settling the htlc until the channel opening was successfull so we can fail it if needed
-        self.dont_settle_htlcs[payment_hash.hex()] = None
+        next_chan = None
         try:
             funding_sat = 2 * (next_amount_msat_htlc // 1000) # try to fully spend htlcs
             password = self.wallet.get_unlocked_password() if self.wallet.has_password() else None
-            channel_opening_fee = next_amount_msat_htlc // 100
-            if channel_opening_fee // 1000 < self.config.ZEROCONF_MIN_OPENING_FEE:
-                self.logger.info(f'rejecting JIT channel: payment too low')
+            channel_opening_fee_msat = (next_amount_msat_htlc * self.config.ZEROCONF_RELATIVE_OPENING_FEE_PPM) // 1_000_000
+            if channel_opening_fee_msat // 1000 < self.config.ZEROCONF_MIN_OPENING_FEE_SAT:
+                self.logger.info(f'rejecting JIT channel: payment too low: posible fee '
+                                 f'{channel_opening_fee_msat//1000} sat < min fee {self.config.ZEROCONF_MIN_OPENING_FEE_SAT} sat')
+                raise OnionRoutingFailure(code=OnionFailureCode.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS, data=b'payment too low')
+            self.logger.info(f'jit channel opening fee (sats): {channel_opening_fee_msat//1000}')
+            try:
+                next_chan, funding_tx = await self.open_channel_with_peer(
+                    next_peer, funding_sat,
+                    push_sat=0,
+                    zeroconf=True,
+                    public=False,
+                    opening_fee_msat=channel_opening_fee_msat,
+                    password=password,
+                )
+            except FeeTooLow:
+                self.logger.info(f"rejecting JIT channel: tx fee too high in relation to revenue", exc_info=True)
                 raise OnionRoutingFailure(code=OnionFailureCode.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS, data=b'payment too low')
-            self.logger.info(f'channel opening fee (sats): {channel_opening_fee//1000}')
-            next_chan, funding_tx = await self.open_channel_with_peer(
-                next_peer, funding_sat,
-                push_sat=0,
-                zeroconf=True,
-                public=False,
-                opening_fee=channel_opening_fee,
-                password=password,
-            )
             async def wait_for_channel():
                 while not next_chan.is_open():
-                    await asyncio.sleep(1)
+                    await asyncio.sleep(0.1)
             await util.wait_for2(wait_for_channel(), LN_P2P_NETWORK_TIMEOUT)
-            next_chan.save_remote_scid_alias(self._scid_alias_of_node(next_peer.pubkey))
-            self.logger.info(f'JIT channel is open')
-            next_amount_msat_htlc -= channel_opening_fee
-            # fixme: some checks are missing
+            self.logger.info(f'JIT channel is open (funding not broadcasted yet)')
+            next_amount_msat_htlc -= channel_opening_fee_msat
             htlc = next_peer.send_htlc(
                 chan=next_chan,
                 payment_hash=payment_hash,
@@ -1282,30 +1319,78 @@ async def wait_for_channel():
                 onion=next_onion)
             async def wait_for_preimage():
                 while self.get_preimage(payment_hash) is None:
-                    await asyncio.sleep(1)
+                    await asyncio.sleep(0.1)
             await util.wait_for2(wait_for_preimage(), LN_P2P_NETWORK_TIMEOUT)
-
-            # We have been paid and can broadcast
-            # todo: if broadcasting raise an exception, we should try to rebroadcast
-            await self.network.broadcast_transaction(funding_tx)
         except OnionRoutingFailure:
             raise
         except Exception:
+            if next_chan:
+                # the chan was already established, so it has to get cleaned up again
+                await self.cleanup_failed_jit_channel(next_chan)
+            raise OnionRoutingFailure(code=OnionFailureCode.TEMPORARY_NODE_FAILURE, data=b'')
+
+        disable_zeroconf = True
+        try:
+            # after 10 mins `update_unfunded_state` will remove the channel on client side so we can fail here too
+            await util.wait_for2(self.broadcast_jit_channel_and_wait_for_mempool(next_chan, funding_tx), ZEROCONF_TIMEOUT - 30)
+            disable_zeroconf = False
+        except Exception:
+            # the risk of the funding tx getting mined later is low as we weren't able to get it into the mempool
+            await self.cleanup_failed_jit_channel(next_chan)
             raise OnionRoutingFailure(code=OnionFailureCode.TEMPORARY_NODE_FAILURE, data=b'')
         finally:
-            del self.dont_settle_htlcs[payment_hash.hex()]
+            if disable_zeroconf:
+                self.logger.warning(f"disabling zeroconf channels to prevent further issues. Check your wallet for consistency.")
+                self.config.ACCEPT_ZEROCONF_CHANNELS = False
+                self.features &= ~LnFeatures.OPTION_ZEROCONF_OPT
 
+        self.sold_just_in_time_channels[funding_tx.txid()] = channel_opening_fee_msat // 1000 - funding_tx.get_fee()
         htlc_key = serialize_htlc_key(next_chan.get_scid_or_local_alias(), htlc.htlc_id)
         return htlc_key
 
+    async def cleanup_failed_jit_channel(self, chan: Channel):
+        """Closes a channel that has no published funding tx (e.g. in case of a failed jit open)"""
+        try:
+            # try to send shutdown to signal peer that channel is dead
+            await util.wait_for2(self.close_channel(chan.channel_id), LN_P2P_NETWORK_TIMEOUT)
+        except Exception:
+            self.logger.debug(f"chan shutdown to failed zeroconf peer failed ", exc_info=True)
+        chan.set_state(ChannelState.REDEEMED, force=True)
+        self.lnwatcher.adb.remove_transaction(chan.funding_outpoint.txid)
+        self.lnwatcher.unwatch_channel(chan.get_funding_address(), chan.funding_outpoint.to_str())
+        self.remove_channel(chan.channel_id)
+
+    async def broadcast_jit_channel_and_wait_for_mempool(self, channel: Channel, funding_tx: Transaction) -> None:
+        last_broadcast_attempt = 0
+        while True:
+            if time.time() - last_broadcast_attempt > 60:
+                try:
+                    await self.network.broadcast_transaction(funding_tx)
+                    self.logger.info(f"broadcasted jit channel open txid: {funding_tx.txid()}")
+                except TxBroadcastServerReturnedError:
+                    self.logger.error(f"we constructed a weird JIT funding tx. Reverting channel again.", exc_info=True)
+                    raise
+                except Exception:
+                    self.logger.warning(f"Broadcasting jit channel open tx {funding_tx.txid()} failed.", exc_info=True)
+                last_broadcast_attempt = time.time()
+
+            # check if the funding tx is at least in the mempool by now
+            funding_info = channel.get_funding_height()
+            if funding_info is not None:
+                _, height, _ = funding_info
+                if height > TX_HEIGHT_LOCAL:
+                    return
+
+            await asyncio.sleep(1)
+
     @log_exceptions
     async def open_channel_with_peer(
             self, peer, funding_sat, *,
             push_sat: int = 0,
             public: bool = False,
             zeroconf: bool = False,
-            opening_fee: int = None,
-            password=None):
+            opening_fee_msat: int = None,
+            password=None) -> Tuple[Channel, PartialTransaction]:
         if self.config.ENABLE_ANCHOR_CHANNELS:
             self.wallet.unlock(password)
         coins = self.wallet.get_spendable_coins(None)
@@ -1316,14 +1401,17 @@ async def open_channel_with_peer(
             funding_sat=funding_sat,
             node_id=node_id,
             fee_policy=fee_policy)
+        if opening_fee_msat and funding_tx.get_fee() * 1000 > opening_fee_msat * 0.5:
+            raise FeeTooLow(f"This channel open is too expensive: fees paid: {funding_tx.get_fee()} sat. "
+                            f"opening fee: {opening_fee_msat // 1000} sat.")
         chan, funding_tx = await self._open_channel_coroutine(
             peer=peer,
             funding_tx=funding_tx,
             funding_sat=funding_sat,
             push_sat=push_sat,
             public=public,
             zeroconf=zeroconf,
-            opening_fee=opening_fee,
+            opening_fee_msat=opening_fee_msat,
             password=password)
         return chan, funding_tx
 
@@ -1336,7 +1424,7 @@ async def _open_channel_coroutine(
             push_sat: int,
             public: bool,
             zeroconf=False,
-            opening_fee=None,
+            opening_fee_msat=None,
             password: Optional[str],
     ) -> Tuple[Channel, PartialTransaction]:
 
@@ -1351,7 +1439,7 @@ async def _open_channel_coroutine(
             push_msat=push_sat * 1000,
             public=public,
             zeroconf=zeroconf,
-            opening_fee=opening_fee,
+            opening_fee=opening_fee_msat,
             temp_channel_id=os.urandom(32))
         chan, funding_tx = await util.wait_for2(coro, LN_P2P_NETWORK_TIMEOUT)
         util.trigger_callback('channels_updated', self.wallet)

electrum/plugins/watchtower/watchtower.py

@@ -189,7 +189,7 @@ async def f():
         return self.network.run_from_another_thread(f())
 
     async def unwatch_channel(self, address, funding_outpoint):
-        await super().unwatch_channel(address, funding_outpoint)
+        super().unwatch_channel(address, funding_outpoint)
         await self.sweepstore.remove_sweep_tx(funding_outpoint)
         await self.sweepstore.remove_channel(funding_outpoint)
         if funding_outpoint in self.tx_progress:

electrum/simple_config.py

@@ -830,9 +830,11 @@ def __setattr__(self, name, value):
     # anchor outputs channels
     ENABLE_ANCHOR_CHANNELS = ConfigVar('enable_anchor_channels', default=False, type_=bool)
     # zeroconf channels
-    ACCEPT_ZEROCONF_CHANNELS = ConfigVar('accept_zeroconf_channels', default=False, type_=bool)
+    ACCEPT_ZEROCONF_CHANNELS = ConfigVar('accept_zeroconf_channels', default=True, type_=bool)
     ZEROCONF_TRUSTED_NODE = ConfigVar('zeroconf_trusted_node', default='', type_=str)
-    ZEROCONF_MIN_OPENING_FEE = ConfigVar('zeroconf_min_opening_fee', default=5000, type_=int)
+    ZEROCONF_MIN_OPENING_FEE_SAT = ConfigVar('zeroconf_min_opening_fee', default=5000, type_=int)
+    # fee deducted from the amount to be forwarded in ppm when opening a zeroconf channel, 1% == 100000 ppm
+    ZEROCONF_RELATIVE_OPENING_FEE_PPM = ConfigVar('zeroconf_relative_opening_fee', default=10000, type_=float)
 
     # connect to remote WT
     WATCHTOWER_CLIENT_URL = ConfigVar('watchtower_url', default=None, type_=str)