AaronFiore/electrum
1
0
Fork 0
Code Activity

Remove LNBackups object: no longer needed since LNWorker is instantiated by default.

Browse Source
This commit is contained in:
ThomasV
2021-03-09 09:55:55 +01:00
parent ef661050c8
commit 652d10aa5f
5 changed files with 46 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
electrum/gui/kivy/uix/dialogs/lightning_channels.py
View File

@@ -410,11 +410,12 @@ Builder.load_string(r'''
class ChannelBackupPopup(Popup, Logger):
def __init__(self, chan: AbstractChannel, app: 'ElectrumWindow', **kwargs):
def __init__(self, chan: AbstractChannel, channels_list, **kwargs):
Popup.__init__(self, **kwargs)
Logger.__init__(self)
self.chan = chan
self.app = app
self.channels_list = channels_list
self.app = channels_list.app
self.short_id = format_short_channel_id(chan.short_channel_id)
self.state = chan.get_state_for_GUI()
self.title = _('Channel Backup')
@@ -427,7 +428,7 @@ class ChannelBackupPopup(Popup, Logger):
if not b:
return
loop = self.app.wallet.network.asyncio_loop
coro = asyncio.run_coroutine_threadsafe(self.app.wallet.lnbackups.request_force_close(self.chan.channel_id), loop)
coro = asyncio.run_coroutine_threadsafe(self.app.wallet.lnworker.request_force_close_from_backup(self.chan.channel_id), loop)
try:
coro.result(5)
self.app.show_info(_('Channel closed'))
@@ -442,7 +443,7 @@ class ChannelBackupPopup(Popup, Logger):
def _remove_backup(self, b):
if not b:
return
self.app.wallet.lnbackups.remove_channel_backup(self.chan.channel_id)
self.app.wallet.lnworker.remove_channel_backup(self.chan.channel_id)
self.dismiss()
@@ -550,9 +551,9 @@ class LightningChannelsDialog(Factory.Popup):
def show_item(self, obj):
chan = obj._chan
if chan.is_backup():
p = ChannelBackupPopup(chan, self.app)
p = ChannelBackupPopup(chan, self)
else:
p = ChannelDetailsPopup(chan, self.app)
p = ChannelDetailsPopup(chan, self)
p.open()
def format_fields(self, chan):
@@ -587,8 +588,7 @@ class LightningChannelsDialog(Factory.Popup):
return
lnworker = self.app.wallet.lnworker
channels = list(lnworker.channels.values()) if lnworker else []
lnbackups = self.app.wallet.lnbackups
backups = list(lnbackups.channel_backups.values())
backups = list(lnworker.channel_backups.values()) if lnworker else []
for i in channels + backups:
item = Factory.LightningChannelItem()
item.screen = self

9
electrum/gui/qt/channels_list.py
View File

@@ -65,7 +65,6 @@ class ChannelsList(MyTreeView):
self.update_single_row.connect(self.do_update_single_row)
self.network = self.parent.network
self.lnworker = self.parent.wallet.lnworker
self.lnbackups = self.parent.wallet.lnbackups
self.setSortingEnabled(True)
def format_fields(self, chan: AbstractChannel) -> Dict['ChannelsList.Columns', str]:
@@ -136,7 +135,7 @@ class ChannelsList(MyTreeView):
def remove_channel_backup(self, channel_id):
if self.main_window.question(_('Remove channel backup?')):
self.lnbackups.remove_channel_backup(channel_id)
self.lnworker.remove_channel_backup(channel_id)
def export_channel_backup(self, channel_id):
msg = ' '.join([
@@ -150,7 +149,7 @@ class ChannelsList(MyTreeView):
def request_force_close(self, channel_id):
def task():
coro = self.lnbackups.request_force_close(channel_id)
coro = self.lnworker.request_force_close_from_backup(channel_id)
return self.network.run_from_another_thread(coro)
def on_success(b):
self.main_window.show_message('success')
@@ -185,7 +184,7 @@ class ChannelsList(MyTreeView):
if not item:
return
channel_id = idx.sibling(idx.row(), self.Columns.NODE_ALIAS).data(ROLE_CHANNEL_ID)
if channel_id in self.lnbackups.channel_backups:
if channel_id in self.lnworker.channel_backups:
menu.addAction(_("Request force-close"), lambda: self.request_force_close(channel_id))
menu.addAction(_("Delete"), lambda: self.remove_channel_backup(channel_id))
menu.exec_(self.viewport().mapToGlobal(position))
@@ -253,7 +252,7 @@ class ChannelsList(MyTreeView):
if wallet != self.parent.wallet:
return
channels = list(wallet.lnworker.channels.values()) if wallet.lnworker else []
backups = list(wallet.lnbackups.channel_backups.values())
backups = list(wallet.lnworker.channel_backups.values()) if wallet.lnworker else []
if wallet.lnworker:
self.update_can_send(wallet.lnworker)
self.model().clear()

13
electrum/lnpeer.py
View File

@@ -52,7 +52,7 @@ from .json_db import StoredDict
from .invoices import PR_PAID
if TYPE_CHECKING:
from .lnworker import LNGossip, LNWallet, LNBackups
from .lnworker import LNGossip, LNWallet
from .lnrouter import LNPaymentRoute
from .transaction import PartialTransaction
@@ -65,10 +65,12 @@ class Peer(Logger):
def __init__(
self,
lnworker: Union['LNGossip', 'LNWallet', 'LNBackups'],
lnworker: Union['LNGossip', 'LNWallet'],
pubkey: bytes,
transport: LNTransportBase
):
transport: LNTransportBase,
*, is_channel_backup= False):
self.is_channel_backup = is_channel_backup
self._sent_init = False # type: bool
self._received_init = False # type: bool
self.initialized = asyncio.Future()
@@ -171,8 +173,7 @@ class Peer(Logger):
def process_message(self, message):
message_type, payload = decode_msg(message)
# only process INIT if we are a backup
from .lnworker import LNBackups
if isinstance(self.lnworker, LNBackups) and message_type != 'init':
if self.is_channel_backup is True and message_type != 'init':
return
if message_type in self.ordered_messages:
chan_id = payload.get('channel_id') or payload["temporary_channel_id"]

86
electrum/lnworker.py
View File

@@ -599,6 +599,11 @@ class LNWallet(LNWorker):
for channel_id, c in random_shuffled_copy(channels.items()):
self._channels[bfh(channel_id)] = Channel(c, sweep_address=self.sweep_address, lnworker=self)
self._channel_backups = {} # type: Dict[bytes, Channel]
channel_backups = self.db.get_dict("channel_backups")
for channel_id, cb in random_shuffled_copy(channel_backups.items()):
self._channel_backups[bfh(channel_id)] = ChannelBackup(cb, sweep_address=self.sweep_address, lnworker=self)
self.sent_htlcs = defaultdict(asyncio.Queue) # type: Dict[bytes, asyncio.Queue[HtlcLog]]
self.sent_htlcs_routes = dict() # (RHASH, scid, htlc_id) -> route, payment_secret, amount_msat, bucket_msat
self.sent_buckets = dict() # payment_secret -> (amount_sent, amount_failed)
@@ -618,6 +623,12 @@ class LNWallet(LNWorker):
with self.lock:
return self._channels.copy()
@property
def channel_backups(self) -> Mapping[bytes, Channel]:
"""Returns a read-only copy of channels."""
with self.lock:
return self._channel_backups.copy()
def get_channel_by_id(self, channel_id: bytes) -> Optional[Channel]:
return self._channels.get(channel_id, None)
@@ -680,6 +691,8 @@ class LNWallet(LNWorker):
for chan in self.channels.values():
self.lnwatcher.add_channel(chan.funding_outpoint.to_str(), chan.get_funding_address())
for cb in self.channel_backups.values():
self.lnwatcher.add_channel(cb.funding_outpoint.to_str(), cb.get_funding_address())
for coro in [
self.maybe_listen(),
@@ -843,7 +856,8 @@ class LNWallet(LNWorker):
if chan.node_id == node_id}
def channel_state_changed(self, chan: Channel):
self.save_channel(chan)
if type(chan) is Channel:
self.save_channel(chan)
util.trigger_callback('channel', self.wallet, chan)
def save_channel(self, chan: Channel):
@@ -857,8 +871,14 @@ class LNWallet(LNWorker):
for chan in self.channels.values():
if chan.funding_outpoint.to_str() == txo:
return chan
for chan in self.channel_backups.values():
if chan.funding_outpoint.to_str() == txo:
return chan
async def on_channel_update(self, chan: Channel):
if type(chan) is ChannelBackup:
util.trigger_callback('channel', self.wallet, chan)
return
if chan.get_state() == ChannelState.OPEN and chan.should_be_closed_due_to_expiring_htlcs(self.network.get_local_height()):
self.logger.info(f"force-closing due to expiring htlcs")
@@ -1940,61 +1960,6 @@ class LNWallet(LNWorker):
peer = await self.add_peer(connect_str)
await peer.trigger_force_close(channel_id)
class LNBackups(Logger):
lnwatcher: Optional['LNWalletWatcher']
def __init__(self, wallet: 'Abstract_Wallet'):
Logger.__init__(self)
self.features = LNWALLET_FEATURES
self.lock = threading.RLock()
self.wallet = wallet
self.db = wallet.db
self.lnwatcher = None
self.channel_backups = {}
for channel_id, cb in random_shuffled_copy(self.db.get_dict("channel_backups").items()):
self.channel_backups[bfh(channel_id)] = ChannelBackup(cb, sweep_address=self.sweep_address, lnworker=self)
@property
def sweep_address(self) -> str:
# TODO possible address-reuse
return self.wallet.get_new_sweep_address_for_channel()
def channel_state_changed(self, chan):
util.trigger_callback('channel', self.wallet, chan)
def peer_closed(self, chan):
pass
async def on_channel_update(self, chan):
util.trigger_callback('channel', self.wallet, chan)
def channel_by_txo(self, txo):
with self.lock:
channel_backups = list(self.channel_backups.values())
for chan in channel_backups:
if chan.funding_outpoint.to_str() == txo:
return chan
def on_peer_successfully_established(self, peer: Peer) -> None:
pass
def channels_for_peer(self, node_id):
return {}
def start_network(self, network: 'Network'):
assert network
self.lnwatcher = LNWalletWatcher(self, network)
self.lnwatcher.start_network(network)
self.network = network
for cb in self.channel_backups.values():
self.lnwatcher.add_channel(cb.funding_outpoint.to_str(), cb.get_funding_address())
def stop(self):
self.lnwatcher.stop()
self.lnwatcher = None
def import_channel_backup(self, data):
assert data.startswith('channel_backup:')
encrypted = data[15:]
@@ -2015,19 +1980,20 @@ class LNBackups(Logger):
d = self.db.get_dict("channel_backups")
if channel_id.hex() not in d:
raise Exception('Channel not found')
d.pop(channel_id.hex())
self.channel_backups.pop(channel_id)
with self.lock:
d.pop(channel_id.hex())
self._channel_backups.pop(channel_id)
self.wallet.save_db()
util.trigger_callback('channels_updated', self.wallet)
@log_exceptions
async def request_force_close(self, channel_id: bytes):
async def request_force_close_from_backup(self, channel_id: bytes):
cb = self.channel_backups[channel_id].cb
# TODO also try network addresses from gossip db (as it might have changed)
peer_addr = LNPeerAddr(cb.host, cb.port, cb.node_id)
transport = LNTransport(cb.privkey, peer_addr,
proxy=self.network.proxy)
peer = Peer(self, cb.node_id, transport)
peer = Peer(self, cb.node_id, transport, is_channel_backup=True)
async with TaskGroup() as group:
await group.spawn(peer._message_loop())
await group.spawn(peer.trigger_force_close(channel_id))

7
electrum/wallet.py
View File

@@ -80,7 +80,7 @@ from .contacts import Contacts
from .interface import NetworkException
from .mnemonic import Mnemonic
from .logging import get_logger
from .lnworker import LNWallet, LNBackups
from .lnworker import LNWallet
from .paymentrequest import PaymentRequest
from .util import read_json_file, write_json_file, UserFacingException
@@ -273,7 +273,6 @@ class Abstract_Wallet(AddressSynchronizer, ABC):
txin_type: str
wallet_type: str
lnworker: Optional['LNWallet']
lnbackups: Optional['LNBackups']
def __init__(self, db: WalletDB, storage: Optional[WalletStorage], *, config: SimpleConfig):
if not db.is_ready_to_be_used_by_wallet():
@@ -310,8 +309,6 @@ class Abstract_Wallet(AddressSynchronizer, ABC):
self._coin_price_cache = {}
self.lnworker = None
# a wallet may have channel backups, regardless of lnworker activation
self.lnbackups = LNBackups(self)
def save_db(self):
if self.storage:
@@ -364,7 +361,6 @@ class Abstract_Wallet(AddressSynchronizer, ABC):
if self.lnworker:
self.lnworker.stop()
self.lnworker = None
self.lnbackups.stop()
self.save_db()
def set_up_to_date(self, b):
@@ -383,7 +379,6 @@ class Abstract_Wallet(AddressSynchronizer, ABC):
# only start gossiping when we already have channels
if self.db.get('channels'):
self.network.start_gossip()
self.lnbackups.start_network(network)
def load_and_cleanup(self):
self.load_keystore()