create_channel_storage: return dict instead of StoredDict

we should avoid dangling StoredDict; this does not make sense
if the DB is not in memory.

Author: ecdsa

electrum/lnchannel.py

@@ -26,6 +26,7 @@
     Iterable, Sequence, TYPE_CHECKING, Iterator, Union, Mapping)
 from abc import ABC, abstractmethod
 import itertools
+import threading
 
 from aiorpcx import NetAddress
 
@@ -790,7 +791,7 @@ def __init__(
         Logger.__init__(self)  # should be after short_channel_id is set
         self.lnworker = lnworker
         self.storage = state
-        self.db_lock = self.storage.lock
+        self.db_lock = threading.RLock() if type(self.storage) is dict else self.storage.lock
         self.config = {}
         self.config[LOCAL] = state["local_config"]
         self.config[REMOTE] = state["remote_config"]
@@ -799,7 +800,7 @@ def __init__(
         self.node_id = bfh(state["node_id"])
         self.onion_keys = state['onion_keys']  # type: Dict[int, bytes]
         self.data_loss_protect_remote_pcp = state['data_loss_protect_remote_pcp']
-        self.hm = HTLCManager(log=state['log'], initiator = LOCAL if self.constraints.is_initiator else REMOTE, initial_feerate=initial_feerate)
+        self.hm = HTLCManager(log=state['log'], initiator = LOCAL if self.constraints.is_initiator else REMOTE, initial_feerate=initial_feerate, lock=self.db_lock)
         self.unfulfilled_htlcs = state["unfulfilled_htlcs"]  # type: Dict[int, Optional[str]]
         # ^ htlc_id -> onion_packet_hex
         self._state = ChannelState[state['state']]

electrum/lnhtlc.py

@@ -1,5 +1,6 @@
 from copy import deepcopy
 from typing import Sequence, Tuple, Dict, TYPE_CHECKING, Set
+import threading
 
 from .lnutil import SENT, RECEIVED, LOCAL, REMOTE, HTLCOwner, UpdateAddHtlc, Direction, FeeUpdate
 from .util import bfh, with_lock
@@ -21,7 +22,7 @@
 
 class HTLCManager:
 
-    def __init__(self, log: 'StoredDict', *, initiator=None, initial_feerate=None):
+    def __init__(self, log: 'StoredDict', *, initiator=None, initial_feerate=None, lock=None):
 
         if len(log) == 0:
             # note: "htlc_id" keys in dict are str! but due to json_db magic they can *almost* be treated as int...
@@ -41,7 +42,7 @@ def __init__(self, log: 'StoredDict', *, initiator=None, initial_feerate=None):
         # lnchannel sometimes calls us with Channel.db_lock (== log.lock) already taken,
         # and we ourselves often take log.lock (via StoredDict.__getitem__).
         # Hence, to avoid deadlocks, we reuse this same lock.
-        self.lock = log.lock
+        self.lock = lock if lock else threading.RLock()
 
         self._init_maybe_active_htlc_ids()
 

electrum/lnpeer.py

@@ -52,7 +52,6 @@
 from .lntransport import LNTransport, LNTransportBase, LightningPeerConnectionClosed, HandshakeFailed
 from .lnmsg import encode_msg, decode_msg, UnknownOptionalMsgType, FailedToParseMsg
 from .interface import GracefulDisconnect
-from .json_db import StoredDict
 from .invoices import PR_PAID
 from .fee_policy import FEE_LN_ETA_TARGET, FEERATE_PER_KW_MIN_RELAY_LIGHTNING
 from .channel_db import FLAG_DIRECTION
@@ -1211,10 +1210,10 @@ async def channel_establishment_flow(
             self.send_warning(channel_id, message=str(e), close_connection=True)
         chan.open_with_first_pcp(remote_per_commitment_point, remote_sig)
         chan.set_state(ChannelState.OPENING)
+        chan = self.lnworker.add_new_channel(chan)
         if zeroconf:
             chan.set_state(ChannelState.FUNDED)
             self.send_channel_ready(chan)
-        self.lnworker.add_new_channel(chan)
         return chan, funding_tx
 
     def create_channel_storage(self, channel_id, outpoint, local_config, remote_config, constraints, channel_type):
@@ -1235,7 +1234,7 @@ def create_channel_storage(self, channel_id, outpoint, local_config, remote_conf
             "revocation_store": {},
             "channel_type": channel_type,
         }
-        return StoredDict(chan_dict, self.lnworker.db)
+        return chan_dict
 
     @non_blocking_msg_handler
     async def on_open_channel(self, payload):
@@ -1431,13 +1430,13 @@ async def on_open_channel(self, payload):
         self.funding_signed_sent.add(chan.channel_id)
         chan.open_with_first_pcp(payload['first_per_commitment_point'], remote_sig)
         chan.set_state(ChannelState.OPENING)
+        chan = self.lnworker.add_new_channel(chan)
         if is_zeroconf:
             # FIXME shouldn't we wait until funding_tx is at least in the mempool?!
             #   We haven't even validated funding_tx really contains the multisig funding output!
             #   This is unsafe. MUST be reworked before mainnet usage.
             chan.set_state(ChannelState.FUNDED)
             self.send_channel_ready(chan)
-        self.lnworker.add_new_channel(chan)
 
     def _cleanup_temp_channelids(self) -> None:
         self.temp_id_to_id = {

electrum/lnworker.py

@@ -1662,16 +1662,31 @@ def add_channel(self, chan: Channel):
         self.lnwatcher.add_channel(chan)
 
     def add_new_channel(self, chan: Channel):
-        self.add_channel(chan)
+        # delete the old channel object, becauses it uses a dict
+        assert type(chan.storage) is dict
+        channel_id = chan.channel_id.hex()
         channels_db = self.db.get_dict('channels')
-        channels_db[chan.channel_id.hex()] = chan.storage
+        channels_db[channel_id] = chan.storage
+        jit_opening_fee = chan.jit_opening_fee
+        peer_state = chan.peer_state
+        del chan
+        storage = channels_db[channel_id] # StoredDict
+        chan = Channel(
+            storage,
+            lnworker=self,
+            jit_opening_fee=jit_opening_fee,
+        )
+        chan.peer_state = peer_state
+        self.add_channel(chan)
         self.wallet.set_reserved_addresses_for_chan(chan, reserved=True)
         try:
             self.save_channel(chan)
         except Exception:
             chan.set_state(ChannelState.REDEEMED)
             self.remove_channel(chan.channel_id)
             raise
+        # return new channel object
+        return chan
 
     def make_local_config_for_new_channel(
         self,

tests/lnhelpers.py

@@ -22,7 +22,6 @@
 from electrum.channel_db import ChannelDB
 from electrum.lnworker import LNWallet, PaySession
 from electrum.simple_config import SimpleConfig
-from electrum.stored_dict import StoredDict
 from electrum.fee_policy import FeeTimeEstimates, FEE_ETA_TARGETS
 from electrum.wallet import  Standard_Wallet
 
@@ -392,7 +391,7 @@ def _create_channel_state(
             'revocation_store': {},
             'channel_type': channel_type,
     }
-    return StoredDict(state, None)
+    return state
 
 
 def create_test_channels(