New LabelSync

This LabelSync is much faster because it will only request labels that
changed since the last sync. It is also using a new back-end and no
longer requires any registration.

plugins/electrum_sync.py

@@ -0,0 +1,204 @@
+from electrum.util import print_error
+
+import socket
+import requests
+import threading
+import hashlib
+import json
+
+try:
+    import PyQt4
+except Exception:
+    sys.exit("Error: Could not import PyQt4 on Linux systems, you may try 'sudo apt-get install python-qt4'")
+
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+import PyQt4.QtCore as QtCore
+import PyQt4.QtGui as QtGui
+import aes
+import base64
+
+import electrum
+from electrum.plugins import BasePlugin, hook
+from electrum.i18n import _
+
+from electrum_gui.qt import HelpButton, EnterButton
+from electrum_gui.qt.util import ThreadedButton, Buttons, CancelButton, OkButton
+
+class Plugin(BasePlugin):
+
+    target_host = 'sync.bysh.me:8080'
+    encode_password = None
+
+    def fullname(self):
+        return _('Electrum Sync')
+
+    def description(self):
+        return '%s\n\n%s' % (_("The new and improved LabelSync plugin. This can sync your labels across multiple Electrum installs by using a remote database to save your data. Labels, transactions ids and addresses are encrypted before they are sent to the remote server."), _("The label sync's server software is open-source as well and can be found on github.com/maran/electrum-sync-server"))
+
+    def version(self):
+        return "0.0.1"
+
+    def encode(self, message):
+        encrypted = electrum.bitcoin.aes_encrypt_with_iv(self.encode_password, self.iv, message.encode('utf8'))
+        encoded_message = base64.b64encode(encrypted)
+        return encoded_message
+
+    def decode(self, message):
+        decoded_message = electrum.bitcoin.aes_decrypt_with_iv(self.encode_password, self.iv, base64.b64decode(message)).decode('utf8')
+        return decoded_message
+
+    def set_nonce(self, nonce):
+        print_error("Set nonce to", nonce)
+        self.wallet.storage.put("wallet_nonce", nonce, True)
+        self.wallet_nonce = nonce
+
+    @hook
+    def init_qt(self, gui):
+        self.window = gui.main_window
+        self.window.connect(self.window, SIGNAL('labels:pulled'), self.on_pulled)
+
+    @hook
+    def load_wallet(self, wallet):
+        self.wallet = wallet
+
+        self.wallet_nonce = self.wallet.storage.get("wallet_nonce")
+        print_error("Wallet nonce is", self.wallet_nonce)
+        if self.wallet_nonce is None:
+            self.set_nonce(1)
+
+        mpk = ''.join(sorted(self.wallet.get_master_public_keys().values()))
+        self.encode_password = hashlib.sha1(mpk).digest().encode('hex')[:32]
+        self.iv = hashlib.sha256(self.encode_password).digest()[:16]
+        self.wallet_id = hashlib.sha256(mpk).digest().encode('hex')
+
+        addresses = []
+        for account in self.wallet.accounts.values():
+            for address in account.get_addresses(0):
+                addresses.append(address)
+
+        self.addresses = addresses
+
+        # If there is an auth token we can try to actually start syncing
+        def do_pull_thread():
+            try:
+                self.pull_thread()
+            except Exception as e:
+                print_error("could not retrieve labels:", e)
+        t = threading.Thread(target=do_pull_thread)
+        t.setDaemon(True)
+        t.start()
+
+
+    def is_available(self):
+        return True
+
+    def requires_settings(self):
+        return True
+
+    @hook
+    def set_label(self, item,label, changed):
+        if self.encode_password is None:
+            return
+        if not changed:
+            return
+        bundle = {"walletId": self.wallet_id, "walletNonce": self.wallet.storage.get("wallet_nonce"), "externalId": self.encode(item), "encryptedLabel": self.encode(label)}
+        t = threading.Thread(target=self.do_request, args=["POST", "/label", False, bundle])
+        t.start()
+        self.set_nonce(self.wallet.storage.get("wallet_nonce") + 1)
+
+    def settings_widget(self, window):
+        return EnterButton(_('Settings'), self.settings_dialog)
+
+    def settings_dialog(self):
+        d = QDialog()
+        vbox = QVBoxLayout(d)
+        layout = QGridLayout()
+        vbox.addLayout(layout)
+
+        layout.addWidget(QLabel("Label sync options: "),2,0)
+
+        self.upload = ThreadedButton("Force upload", self.push_thread, self.done_processing)
+        layout.addWidget(self.upload, 2, 1)
+
+        self.download = ThreadedButton("Force download", lambda: self.pull_thread(True), self.done_processing)
+        layout.addWidget(self.download, 2, 2)
+
+        self.accept = OkButton(d, _("Done"))
+        vbox.addLayout(Buttons(CancelButton(d), self.accept))
+
+        if d.exec_():
+            return True
+        else:
+            return False
+
+    def on_pulled(self):
+        wallet = self.wallet
+        wallet.storage.put('labels', wallet.labels, True)
+        self.window.labelsChanged.emit()
+
+    def done_processing(self):
+        QMessageBox.information(None, _("Labels synchronised"), _("Your labels have been synchronised."))
+
+    def do_request(self, method, url = "/labels", is_batch=False, data=None):
+        url = 'http://' + self.target_host + url
+        kwargs = {'headers': {}}
+        if method == 'GET' and data:
+            kwargs['params'] = data
+        elif method == 'POST' and data:
+            kwargs['data'] = json.dumps(data)
+            kwargs['headers']['Content-Type'] = 'application/json'
+        response = requests.request(method, url, **kwargs)
+        if response.status_code != 200:
+            raise BaseException(response.status_code, response.text)
+        response = response.json()
+        if "error" in response:
+            raise BaseException(response["error"])
+        return response
+
+    def push_thread(self):
+        bundle = {"labels": [], "walletId": self.wallet_id, "walletNonce": self.wallet_nonce}
+        for key, value in self.wallet.labels.iteritems():
+            try:
+                encoded_key = self.encode(key)
+                encoded_value = self.encode(value)
+            except:
+                print_error('cannot encode', repr(key), repr(value))
+                continue
+            bundle["labels"].append({'encryptedLabel': encoded_value, 'externalId':  encoded_key})
+        self.do_request("POST", "/labels", True, bundle)
+
+    def pull_thread(self, force = False):
+        if force:
+            wallet_nonce = 1
+        else:
+            wallet_nonce = self.wallet_nonce - 1
+
+        print_error("Asking for labels since nonce", wallet_nonce)
+        response = self.do_request("GET", ("/labels/since/%d/for/%s" % (wallet_nonce, self.wallet_id) ))
+        result = {}
+        if not response["labels"] is None:
+            for label in response["labels"]:
+                try:
+                    key = self.decode(label["externalId"])
+                    value = self.decode(label["encryptedLabel"])
+                except:
+                    continue
+                try:
+                    json.dumps(key)
+                    json.dumps(value)
+                except:
+                    print_error('error: no json', key)
+                    continue
+                result[key] = value
+
+            wallet = self.wallet
+            if not wallet:
+                return
+            for key, value in result.items():
+                if force or not wallet.labels.get(key):
+                    wallet.labels[key] = value
+
+            self.window.emit(SIGNAL('labels:pulled'))
+            self.set_nonce(response["nonce"] + 1)
+            print_error("received %d labels"%len(response))