Start sakia with files version 0.12

src/sakia/core/net/network.py

@@ -9,8 +9,7 @@ import logging
 import aiohttp
 import time
 import asyncio
-from ucoinpy.documents.peer import Peer
-from ucoinpy.documents.block import Block, BlockUID
+from ucoinpy.documents import Peer,  Block, BlockUID, MalformedDocumentError
 from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject, QTimer
 from collections import Counter
 
@@ -67,7 +66,8 @@ class Network(QObject):
         :param NormalizedVersion file_version: The node version
         """
         for data in json_data:
-            node = Node.from_json(self.currency, data, file_version)
+            try:
+                node = Node.from_json(self.currency, data, file_version, self.session)
                 if node.pubkey not in [n.pubkey for n in self.nodes]:
                     self.add_node(node)
                     logging.debug("Loading : {:}".format(data['pubkey']))
@@ -87,6 +87,8 @@ class Network(QObject):
                         other_node.set_block(node.block)
                         other_node.last_change = node.last_change
                         other_node.state = node.state
+            except MalformedDocumentError:
+                logging.debug("Could not load node {0}".format(data))
 
     @classmethod
     def from_json(cls, currency, json_data, file_version):
@@ -100,8 +102,11 @@ class Network(QObject):
         session = aiohttp.ClientSession()
         nodes = []
         for data in json_data:
+            try:
                 node = Node.from_json(currency, data, file_version, session)
                 nodes.append(node)
+            except MalformedDocumentError:
+                logging.debug("Could not load node {0}".format(data))
         network = cls(currency, nodes, session)
         return network
 
@@ -123,6 +128,9 @@ class Network(QObject):
         """
         synced = len(self.synced_nodes)
         total = len(self.nodes)
+        if total == 0:
+            ratio_synced = 0
+        else:
             ratio_synced = synced / total
         return ratio_synced
 
@@ -141,6 +149,7 @@ class Network(QObject):
         close_tasks = []
         for node in self.nodes:
             close_tasks.append(asyncio.ensure_future(node.close_ws()))
+        if len(close_tasks) > 0:
             await asyncio.wait(close_tasks, timeout=15)
         await self._client_session.close()
         logging.debug("Closed")
@@ -336,6 +345,7 @@ class Network(QObject):
                     if not first_loop:
                         await asyncio.sleep(15)
             first_loop = False
+            await asyncio.sleep(15)
 
         logging.debug("End of network discovery")
 

src/sakia/core/registry/identities.py

 from ucoinpy.api import bma
 from ucoinpy.documents import BlockUID
 from .identity import Identity, LocalState, BlockchainState
-
+from pkg_resources import parse_version
 import asyncio
 from aiohttp.errors import ClientError
 from ...tools.exceptions import NoPeerAvailable
@@ -28,12 +28,13 @@ class IdentitiesRegistry:
         :param dict json_data: The identities in json format
         """
         instances = {}
+        version = parse_version(json_data['version'])
         for currency in json_data['registry']:
             instances[currency] = {}
             for person_data in json_data['registry'][currency]:
                 pubkey = person_data['pubkey']
                 if pubkey not in instances:
-                    person = Identity.from_json(person_data)
+                    person = Identity.from_json(person_data, version)
                     instances[currency][person.pubkey] = person
         self._instances = instances
 

src/sakia/core/registry/identity.py

@@ -7,6 +7,7 @@ Created on 11 févr. 2014
 import logging
 import time
 from enum import Enum
+from pkg_resources import parse_version
 
 from ucoinpy.documents import BlockUID, SelfCertification, MalformedDocumentError
 from ucoinpy.api import bma as bma
@@ -76,7 +77,7 @@ class Identity(QObject):
         return cls(uid, pubkey, sigdate, LocalState.COMPLETED, blockchain_state)
 
     @classmethod
-    def from_json(cls, json_data):
+    def from_json(cls, json_data, version):
         """
         Create a person from json data
 
@@ -85,9 +86,12 @@ class Identity(QObject):
         """
         pubkey = json_data['pubkey']
         uid = json_data['uid']
-        sigdate = BlockUID.from_str(json_data['sigdate'])
         local_state = LocalState[json_data['local_state']]
         blockchain_state = BlockchainState[json_data['blockchain_state']]
+        if version < parse_version("0.20.0dev0"):
+            sigdate = BlockUID.empty()
+        else:
+            sigdate = BlockUID.from_str(json_data['sigdate'])
 
         return cls(uid, pubkey, sigdate, local_state, blockchain_state)
 
@@ -512,7 +516,7 @@ class Identity(QObject):
         """
         data = {'uid': self.uid,
                 'pubkey': self.pubkey,
-                'sigdate': self._sigdate,
+                'sigdate': str(self._sigdate),
                 'local_state': self.local_state.name,
                 'blockchain_state': self.blockchain_state.name}
         return data

src/sakia/core/txhistory.py

@@ -28,12 +28,19 @@ class TxHistory():
     def latest_block(self, value):
         self._latest_block = value
 
-    def load_from_json(self, data):
+    def load_from_json(self, data, version):
+        """
+        Load the tx history cache from json data
+
+        :param dict data: the data
+        :param version: the version parsed with pkg_resources.parse_version
+        :return:
+        """
         self._transfers = []
 
         data_sent = data['transfers']
         for s in data_sent:
-            self._transfers.append(Transfer.load(s))
+            self._transfers.append(Transfer.load(s, version))
 
         for s in data['sources']:
             self.available_sources.append(InputSource.from_inline(s['inline']))

src/sakia/core/wallet.py

@@ -14,6 +14,7 @@ from ..tools.exceptions import NotEnoughMoneyError, NoPeerAvailable, LookupFailu
 from .transfer import Transfer
 from .txhistory import TxHistory
 
+from pkg_resources import parse_version
 from PyQt5.QtCore import QObject, pyqtSignal
 
 import logging
@@ -78,10 +79,12 @@ class Wallet(QObject):
 
         :param dict json_data: The caches as a dict in json format
         """
+        version = parse_version(json_data['version'])
         for currency in json_data:
             if currency != 'version':
                 self.caches[currency] = TxHistory(app, self)
-                self.caches[currency].load_from_json(json_data[currency])
+                if version >= parse_version("0.20.dev0"):
+                    self.caches[currency].load_from_json(json_data[currency], version)
 
     def jsonify_caches(self):
         """