stored_dict: perform type conversions at request time

Author: ecdsa

electrum/invoices.py

@@ -236,7 +236,7 @@ def get_id(self) -> str:
         else:  # on-chain
             return get_id_from_onchain_outputs(outputs=self.get_outputs(), timestamp=self.time)
 
-    def as_dict(self, status):
+    def export(self, status):
         d = {
             'is_lightning': self.is_lightning(),
             'amount_BTC': format_satoshis(self.get_amount_sat()),
@@ -298,7 +298,7 @@ def can_be_paid_onchain(self) -> bool:
             return True
 
     def to_debug_json(self) -> Dict[str, Any]:
-        d = self.to_json()
+        d = self.as_dict()
         d["lnaddr"] = self._lnaddr.to_debug_json()
         return d
 

electrum/json_db.py

@@ -30,9 +30,9 @@
 import jsonpatch
 import jsonpointer
 
-from .util import WalletFileException, profiler, sticky_property, MyEncoder
+from .util import WalletFileException, profiler, sticky_property
 from .logging import Logger
-from .stored_dict import _FLEX_KEY, BaseDB, _convert_dict_key, _convert_dict_value
+from .stored_dict import _FLEX_KEY, BaseDB
 from .storage import FileStorage
 
 
@@ -51,6 +51,8 @@
 setattr(jsonpatch.JsonPatchException, '__suppress_context__', sticky_property(True))
 
 
+
+
 def key_path(path: Sequence[_FLEX_KEY], key: _FLEX_KEY) -> str:
     def to_str(x: _FLEX_KEY) -> str:
         assert isinstance(x, _FLEX_KEY), repr(x)
@@ -66,6 +68,7 @@ def to_str(x: _FLEX_KEY) -> str:
     return '/'.join(items)
 
 
+
 def modifier(func):
     def wrapper(self, *args, **kwargs):
         with self.lock:
@@ -89,14 +92,10 @@ def __init__(
             *,
             allow_partial_writes = True,
             init_db = True,
-            encoder = MyEncoder,
-            upgrader = None,
     ):
         BaseDB.__init__(self, path)
         self._is_closed = True
         self.lock = threading.RLock()
-        self.encoder = encoder
-        self.upgrader = upgrader
         self.pending_changes = []  # type: List[str]
         self._modified = False
         if self.path:
@@ -107,21 +106,17 @@ def __init__(
                 self.init_db()
         else:
             self.storage = None
-            self.set_data('{}')
+            self.json_data = {}
             self._is_closed = False
 
     def set_data(self, json_str):
-        data = self.load_data(json_str)
-        if self.upgrader:
-            data, was_upgraded = self.upgrader(data)
-            self._modified |= was_upgraded
-        self.json_data = self._convert_dict([], data)
+        self.json_data = self.load_data(json_str)
 
     def init_db(self):
         if self.storage.is_encrypted():
             assert self.storage.is_past_initial_decryption()
         json_str = self.storage.read()
-        self.set_data(json_str)
+        self.json_data = self.load_data(json_str)
         # write file in case there was a db upgrade
         self.write_and_force_consolidation()
         self._is_closed = False
@@ -176,7 +171,7 @@ def contains(self, path, key):
 
     def replace(self, path, key, value):
         # called by setattr
-        self.db_replace(path, key, value)
+        self.put(path, key, value)
 
     @modifier
     def put(self, path, key, value):
@@ -298,7 +293,7 @@ def modified(self):
 
     @locked
     def add_patch(self, patch):
-        self.pending_changes.append(json.dumps(patch, cls=self.encoder))
+        self.pending_changes.append(json.dumps(patch))
         self.set_modified(True)
 
     def db_add(self, path, key: _FLEX_KEY, value) -> None:
@@ -322,29 +317,8 @@ def dump(self, *, human_readable: bool = True) -> str:
             self.json_data,
             indent=4 if human_readable else None,
             sort_keys=bool(human_readable),
-            cls=self.encoder,
         )
 
-    def _convert_dict_key(self, path: List[str], key: str) -> _FLEX_KEY:
-        return _convert_dict_key(path, key)
-
-    def _convert_dict_value(self, path: List[str], v) -> Any:
-        v = _convert_dict_value(path, v)
-        if isinstance(v, dict):
-            v = self._convert_dict(path, v)
-        return v
-
-    def _convert_dict(self, path: List[str], data: dict):
-        # recursively convert json dict to StoredDict
-        assert all(isinstance(x, str) for x in path), repr(path)
-        d = {}
-        for k, v in list(data.items()):
-            child_path = path + [k]
-            k = self._convert_dict_key(path, k)
-            v = self._convert_dict_value(child_path, v)
-            d[k] = v
-        return d
-
     @locked
     def write(self):
         if not self.storage:

electrum/lnchannel.py

@@ -62,6 +62,7 @@
 from .lnutil import ChannelBackupStorage, ImportedChannelBackupStorage, OnchainChannelBackupStorage
 from .lnutil import format_short_channel_id
 from .fee_policy import FEERATE_PER_KW_MIN_RELAY_LIGHTNING
+from .stored_dict import stored_at
 
 if TYPE_CHECKING:
     from .lnworker import LNWallet

electrum/lnpeer.py

@@ -1184,7 +1184,7 @@ async def channel_establishment_flow(
             lnworker=self.lnworker,
             initial_feerate=feerate
         )
-        chan.storage['funding_inputs'] = [txin.prevout.to_json() for txin in funding_tx.inputs()]
+        chan.storage['funding_inputs'] = [txin.prevout for txin in funding_tx.inputs()]
         chan.storage['has_onchain_backup'] = has_onchain_backup
         chan.storage['init_height'] = self.lnworker.network.get_local_height()
         chan.storage['init_timestamp'] = int(time.time())
@@ -1216,7 +1216,7 @@ async def channel_establishment_flow(
             self.send_channel_ready(chan)
         return chan, funding_tx
 
-    def create_channel_storage(self, channel_id, outpoint, local_config, remote_config, constraints, channel_type):
+    def create_channel_storage(self, channel_id, outpoint, local_config, remote_config, constraints, channel_type) -> dict:
         chan_dict = {
             "node_id": self.pubkey.hex(),
             "channel_id": channel_id.hex(),

electrum/lnutil.py

@@ -1942,7 +1942,7 @@ def from_tuple(amount_msat, rhash, cltv_abs, htlc_id, timestamp) -> 'UpdateAddHt
             htlc_id=htlc_id,
             timestamp=timestamp)
 
-    def to_json(self):
+    def as_tuple(self):
         self._validate()
         return dataclasses.astuple(self)