use WaitingDialog to close channels

electrum/gui/qt/channels_list.py

@@ -40,22 +40,26 @@ class ChannelsList(MyTreeWidget):
         ]
 
     def create_menu(self, position):
+        from .util import WaitingDialog
+        network = self.parent.network
+        lnworker = self.parent.wallet.lnworker
         menu = QMenu()
         channel_id = self.currentItem().data(0, QtCore.Qt.UserRole)
+        def on_success(txid):
+            self.main_window.show_error('Channel closed' + '\n' + txid)
+        def on_failure(exc_info):
+            type_, e, traceback = exc_info
+            self.main_window.show_error('Failed to close channel:\n{}'.format(repr(e)))
         def close():
-            netw = self.parent.network
-            coro = self.parent.wallet.lnworker.close_channel(channel_id)
-            try:
-                _txid = netw.run_from_another_thread(coro)
-            except Exception as e:
-                self.main_window.show_error('Force-close failed:\n{}'.format(repr(e)))
+            def task():
+                coro = lnworker.close_channel(channel_id)
+                return network.run_from_another_thread(coro)
+            WaitingDialog(self, 'please wait..', task, on_success, on_failure)
         def force_close():
-            netw = self.parent.network
-            coro = self.parent.wallet.lnworker.force_close_channel(channel_id)
-            try:
-                _txid = netw.run_from_another_thread(coro)
-            except Exception as e:
-                self.main_window.show_error('Force-close failed:\n{}'.format(repr(e)))
+            def task():
+                coro = lnworker.force_close_channel(channel_id)
+                return network.run_from_another_thread(coro)
+            WaitingDialog(self, 'please wait..', task, on_success, on_failure)
         menu.addAction(_("Close channel"), close)
         menu.addAction(_("Force-close channel"), force_close)
         menu.exec_(self.viewport().mapToGlobal(position))

electrum/lnbase.py

@@ -1129,8 +1129,9 @@ class Peer(PrintError):
         self.shutdown_received[chan_id] = asyncio.Future()
         self.send_shutdown(chan)
         payload = await self.shutdown_received[chan_id]
-        await self._shutdown(chan, payload)
-        self.network.trigger_callback('ln_message', self.lnworker, 'Channel closed')
+        txid = await self._shutdown(chan, payload)
+        self.print_error('Channel closed', txid)
+        return txid
 
     @log_exceptions
     async def on_shutdown(self, payload):
@@ -1140,12 +1141,11 @@ class Peer(PrintError):
         chan_id = payload['channel_id']
         if chan_id in self.shutdown_received:
             self.shutdown_received[chan_id].set_result(payload)
-            self.print_error('Channel closed by us')
         else:
             chan = self.channels[chan_id]
             self.send_shutdown(chan)
-            await self._shutdown(chan, payload)
-            self.print_error('Channel closed by remote peer')
+            txid = await self._shutdown(chan, payload)
+            self.print_error('Channel closed by remote peer', txid)
 
     def send_shutdown(self, chan):
         scriptpubkey = bfh(bitcoin.address_to_script(chan.sweep_address))
@@ -1154,7 +1154,7 @@ class Peer(PrintError):
     @log_exceptions
     async def _shutdown(self, chan, payload):
         scriptpubkey = bfh(bitcoin.address_to_script(chan.sweep_address))
-        signature, fee = chan.make_closing_tx(scriptpubkey, payload['scriptpubkey'])
+        signature, fee, txid = chan.make_closing_tx(scriptpubkey, payload['scriptpubkey'])
         self.send_message('closing_signed', channel_id=chan.channel_id, fee_satoshis=fee, signature=signature)
         while chan.get_state() != 'CLOSED':
             try:
@@ -1163,5 +1163,6 @@ class Peer(PrintError):
                 pass
             else:
                 fee = int.from_bytes(closing_signed['fee_satoshis'], 'big')
-                signature, _ = chan.make_closing_tx(scriptpubkey, payload['scriptpubkey'], fee_sat=fee)
+                signature, _, txid = chan.make_closing_tx(scriptpubkey, payload['scriptpubkey'], fee_sat=fee)
                 self.send_message('closing_signed', channel_id=chan.channel_id, fee_satoshis=fee, signature=signature)
+        return txid

electrum/lnchan.py

@@ -757,7 +757,7 @@ class Channel(PrintError):
 
         der_sig = bfh(closing_tx.sign_txin(0, self.config[LOCAL].multisig_key.privkey))
         sig = ecc.sig_string_from_der_sig(der_sig[:-1])
-        return sig, fee_sat
+        return sig, fee_sat, closing_tx.txid()
 
 def maybe_create_sweeptx_for_their_ctx_to_remote(chan, ctx, their_pcp: bytes,
                                                  sweep_address) -> Optional[EncumberedTransaction]:

electrum/lnworker.py

@@ -421,7 +421,7 @@ class LNWorker(PrintError):
     async def close_channel(self, chan_id):
         chan = self.channels[chan_id]
         peer = self.peers[chan.node_id]
-        await peer.close_channel(chan_id)
+        return await peer.close_channel(chan_id)
 
     async def force_close_channel(self, chan_id):
         chan = self.channels[chan_id]
@@ -437,9 +437,7 @@ class LNWorker(PrintError):
         none_idx = tx._inputs[0]["signatures"].index(None)
         tx.add_signature_to_txin(0, none_idx, bh2u(remote_sig))
         assert tx.is_complete()
-        txid = await self.network.broadcast_transaction(tx)
-        self.network.trigger_callback('ln_message', self, 'Channel closed' + '\n' + txid)
-        return txid
+        return await self.network.broadcast_transaction(tx)
 
     def _get_next_peers_to_try(self) -> Sequence[LNPeerAddr]:
         now = time.time()