Starting to implement new tx API

src/cutecoin/core/net/api/bma/__init__.py

@@ -122,8 +122,8 @@ class API(object):
         request.setHeader(QNetworkRequest.ContentTypeHeader,
             "application/x-www-form-urlencoded")
         reply = self.conn_handler.network_manager.post(request,
-                             post_data.toString(QUrl.FullyEncoded))
-
+                             post_data.toString(QUrl.FullyEncoded).encode('utf-8'))
+        logging.debug(url.toString(QUrl.FullyEncoded))
         return reply
 
 from . import network, blockchain, tx, wot

src/cutecoin/core/net/api/bma/tx/__init__.py

@@ -35,6 +35,27 @@ class Process(Tx):
         return self.requests_post('/process', **kwargs)
 
 
+class History(Tx):
+    """Get transaction sources."""
+
+    null_value = {
+        "currency": "",
+        "pubkey": "",
+        "history": {
+            "sent": [],
+            "received": []
+        }
+    }
+
+    def __init__(self, conn_handler, pubkey, module='tx'):
+        super(Tx, self).__init__(conn_handler, module)
+        self.pubkey = pubkey
+
+    def __get__(self, **kwargs):
+        assert self.pubkey is not None
+        return self.requests_get('/history/%s' % self.pubkey, **kwargs)
+
+
 class Sources(Tx):
     """Get transaction sources."""
 

src/cutecoin/core/net/api/bma/tx/history/__init__.py

+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors:
+# Caner Candan <caner@candan.fr>, http://caner.candan.fr
+#
+
+from .. import History, logging
+
+logger = logging.getLogger("ucoin/tx")
+
+
+class Blocks(History):
+    def __init__(self, conn_handler, pubkey, from_, to_, module='blocks'):
+        super(History, self).__init__(conn_handler, pubkey, module)
+        self.from_ = from_
+        self.to_ = to_
+
+    null_value = {
+        "currency": "",
+        "pubkey": "",
+        "history": {
+            "sent": [],
+            "received": []
+        }
+    }
+
+    def __get__(self, **kwargs):
+        return self.requests_get('/blocks/{0}/{1}'.format(self.from_, self.to_) **kwargs)

src/cutecoin/core/net/api/bma/ud/__init__.py

+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors:
+# Caner Candan <caner@candan.fr>, http://caner.candan.fr
+#
+
+from .. import API, logging
+
+logger = logging.getLogger("ucoin/ud")
+
+
+class Ud(API):
+    def __init__(self, conn_handler, module='ud'):
+        super(Ud, self).__init__(conn_handler, module)
+
+
+
+class History(Ud):
+    """Get UD history."""
+
+    null_value = {
+        "currency": "",
+        "pubkey": "",
+        "history": {
+            "history": []
+        }
+    }
+
+    def __init__(self, conn_handler, pubkey, module='ud'):
+        super(Ud, self).__init__(conn_handler, module)
+        self.pubkey = pubkey
+
+    def __get__(self, **kwargs):
+        assert self.pubkey is not None
+        return self.requests_get('/history/%s' % self.pubkey, **kwargs)

src/cutecoin/core/transfer.py

@@ -4,11 +4,13 @@ Created on 31 janv. 2015
 @author: inso
 '''
 import logging
-from ucoinpy.api import bma
 from ucoinpy.documents.transaction import Transaction
+from .net.api import bma as qtbma
+from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject
+from PyQt5.QtNetwork import QNetworkReply
+import hashlib
 
-
-class Transfer(object):
+class Transfer(QObject):
     '''
     A transfer is the lifecycle of a transaction.
     TO_SEND means the transaction wasn't sent yet
@@ -25,7 +27,10 @@ class Transfer(object):
     REFUSED = 3
     DROPPED = 5
 
-    def __init__(self, txdoc, state, metadata):
+    transfer_broadcasted = pyqtSignal()
+    broadcast_error = pyqtSignal(str, str)
+
+    def __init__(self, hash, state, metadata):
         '''
         The constructor of a transfer.
         Check for metadata keys which must be present :
@@ -50,7 +55,7 @@ class Transfer(object):
         assert('receiver_uid' in metadata)
         assert('txid' in metadata)
 
-        self.txdoc = txdoc
+        self.hash = hash
         self.state = state
         self._metadata = metadata
 
@@ -62,22 +67,18 @@ class Transfer(object):
         return cls(None, Transfer.TO_SEND, metadata)
 
     @classmethod
-    def create_validated(cls, txdoc, metadata):
+    def create_validated(cls, hash, metadata):
         '''
         Create a new transfer in a "VALIDATED" state.
         '''
-        return cls(txdoc, Transfer.VALIDATED, metadata)
+        return cls(hash, Transfer.VALIDATED, metadata)
 
     @classmethod
     def load(cls, data):
         '''
         Create a new transfer from a dict in json format.
         '''
-        if data['state'] is Transfer.TO_SEND:
-            txdoc = None
-        else:
-            txdoc = Transaction.from_signed_raw(data['txdoc'])
-        return cls(txdoc, data['state'], data['metadata'])
+        return cls(data['hash'], data['state'], data['metadata'])
 
     @property
     def metadata(self):
@@ -90,11 +91,7 @@ class Transfer(object):
         '''
         :return: The transfer as a dict in json format
         '''
-        if self.txdoc:
-            txraw = self.txdoc.signed_raw()
-        else:
-            txraw = None
-        return {'txdoc': txraw,
+        return {'hash': self.hash,
                 'state': self.state,
                 'metadata': self._metadata}
 
@@ -107,19 +104,33 @@ class Transfer(object):
         :param txdoc: A transaction ucoinpy object
         :param community: The community target of the transaction
         '''
-        try:
-            self.txdoc = txdoc
-            community.broadcast(bma.tx.Process,
+        replies = community.bma_access.broadcast(qtbma.tx.Process,
                     post_args={'transaction': self.txdoc.signed_raw()})
+        for r in replies:
+            r.finished.connect(lambda reply=r: self.__handle_transfers_reply(replies, reply))
+
         self.state = Transfer.AWAITING
-        except ValueError as e:
-            if '400' in str(e):
-                self.state = Transfer.REFUSED
-            raise
-        finally:
+        self.hash = hashlib.sha1(txdoc.signed_raw().encode("ascii")).hexdigest().upper()
         self._metadata['block'] = community.current_blockid()['number']
         self._metadata['time'] = community.get_block().mediantime
 
+    def __handle_transfers_reply(self, replies, reply):
+        strdata = bytes(reply.readAll()).decode('utf-8')
+        logging.debug("Received reply : {0} : {1}".format(reply.error(), strdata))
+        if reply.error() == QNetworkReply.NoError:
+            self.transfer_broadcasted.emit()
+            for r in replies:
+                try:
+                    r.disconnect()
+                except TypeError as e:
+                    if "disconnect()" in str(e):
+                        logging.debug("Could not disconnect a reply")
+        else:
+            for r in replies:
+                if not r.isFinished() or r.error() == QNetworkReply.NoError:
+                    return
+            self.broadcast_error.emit(r.error(), strdata)
+
     def check_registered(self, tx, block, time):
         '''
         Check if the transfer was registered in a block.
@@ -154,14 +165,14 @@ class Transfer(object):
 
 
 class Received(Transfer):
-    def __init__(self, txdoc, metadata):
+    def __init__(self, hash, metadata):
         '''
         A transfer were the receiver is the local user.
 
         :param txdoc: The transaction document of the received transfer
         :param metadata: The metadata of the transfer
         '''
-        super().__init__(txdoc, Transfer.VALIDATED, metadata)
+        super().__init__(hash, Transfer.VALIDATED, metadata)
 
     @classmethod
     def load(cls, data):
@@ -170,5 +181,4 @@ class Received(Transfer):
 
         :param data: The transfer as a dict in json format
         '''
-        txdoc = Transaction.from_signed_raw(data['txdoc'])
-        return cls(txdoc, data['metadata'])
+        return cls(data['hash'], data['metadata'])

src/cutecoin/core/wallet.py

@@ -66,42 +66,43 @@ class Cache():
     def transfers(self):
         return [t for t in self._transfers if t.state != Transfer.DROPPED]
 
-    def _parse_transaction(self, community, tx, block_number,
-                           mediantime, received_list, txid):
-        #logging.debug(tx.signed_raw())
-        receivers = [o.pubkey for o in tx.outputs
-                     if o.pubkey != tx.issuers[0]]
+    def _parse_transaction(self, community, txdata, received_list, txid):
+        receivers = [o.pubkey for o in txdata['outputs']
+                     if o.pubkey != txdata['issuers'][0]]
 
-        if len(receivers) == 0:
-            receivers = [tx.issuers[0]]
-
-        try:
-            issuer_uid = Person.lookup(tx.issuers[0], community).uid
-        except LookupFailureError:
-            issuer_uid = ""
+        block_number = txdata['block']
+        mediantime = txdata['time']
 
-        try:
-            receiver_uid = Person.lookup(receivers[0], community).uid
-        except LookupFailureError:
-            receiver_uid = ""
+        if len(receivers) == 0:
+            receivers = [txdata['issuers'][0]]
+        #
+        # try:
+        #     issuer_uid = IdentitiesRegistry.lookup(txdata['issuers'][0], community).uid
+        # except LookupFailureError:
+        #     issuer_uid = ""
+        #
+        # try:
+        #     receiver_uid = IdentitiesRegistry.lookup(receivers[0], community).uid
+        # except LookupFailureError:
+        #     receiver_uid = ""
 
         metadata = {'block': block_number,
                     'time': mediantime,
-                    'comment': tx.comment,
-                    'issuer': tx.issuers[0],
-                    'issuer_uid': issuer_uid,
+                    'comment': txdata['comment'],
+                    'issuer': txdata['issuers'][0],
+                    'issuer_uid': "",#issuer_uid,
                     'receiver': receivers[0],
-                    'receiver_uid': receiver_uid,
+                    'receiver_uid': "",#receiver_uid,
                     'txid': txid}
 
-        in_issuers = len([i for i in tx.issuers
+        in_issuers = len([i for i in txdata['issuers']
                      if i == self.wallet.pubkey]) > 0
-        in_outputs = len([o for o in tx.outputs
+        in_outputs = len([o for o in txdata['outputs']
                        if o.pubkey == self.wallet.pubkey]) > 0
 
         # If the wallet pubkey is in the issuers we sent this transaction
         if in_issuers:
-            outputs = [o for o in tx.outputs
+            outputs = [o for o in txdata['outputs']
                        if o.pubkey != self.wallet.pubkey]
             amount = 0
             for o in outputs:
@@ -111,49 +112,23 @@ class Cache():
             awaiting = [t for t in self._transfers
                         if t.state == Transfer.AWAITING]
             # We check if the transaction correspond to one we sent
-            if tx.signed_raw() not in [t.txdoc.signed_raw() for t in awaiting]:
-                transfer = Transfer.create_validated(tx,
+            if txdata['hash'] not in [t['hash'] for t in awaiting]:
+                transfer = Transfer.create_validated(txdata,
                                                      metadata.copy())
                 self._transfers.append(transfer)
         # If we are not in the issuers,
         # maybe it we are in the recipients of this transaction
         elif in_outputs:
-            outputs = [o for o in tx.outputs
+            outputs = [o for o in txdata.outputs
                        if o.pubkey == self.wallet.pubkey]
             amount = 0
             for o in outputs:
                 amount += o.amount
             metadata['amount'] = amount
-            received = Received(tx, metadata.copy())
+            received = Received(txdata, metadata.copy())
             received_list.append(received)
             self._transfers.append(received)
 
-
-    def _parse_block(self, community, block_number, received_list):
-        block = community.request(bma.blockchain.Block,
-                                  req_args={'number': block_number})
-        signed_raw = "{0}{1}\n".format(block['raw'],
-                                       block['signature'])
-        try:
-            block_doc = Block.from_signed_raw(signed_raw)
-        except:
-            logging.debug("Error in {0}".format(block_number))
-            raise
-        for (txid, tx) in enumerate(block_doc.transactions):
-            self._parse_transaction(community, tx, block_number,
-                                    block_doc.mediantime, received_list,
-                                    txid)
-
-        logging.debug("Received {0} transactions".format(len(received_list)))
-        awaiting = [t for t in self._transfers
-                    if t.state == Transfer.AWAITING]
-        # After we checked all transactions, we check if
-        # sent transactions still waiting for validation
-        # have to be considered refused
-        for transfer in awaiting:
-            transfer.check_registered(tx, block_number,
-                                      block_doc.mediantime)
-
     def refresh(self, community, received_list):
         current_block = 0
         try:
@@ -163,22 +138,14 @@ class Cache():
             # Lets look if transactions took too long to be validated
             awaiting = [t for t in self._transfers
                         if t.state == Transfer.AWAITING]
-            with_tx = community.request(bma.blockchain.TX)
+            tx_history = community.bma_access.request(qtbma.tx.history.Blocks,
+                                                      req_args={'pubkey': self.wallet.pubkey,
+                                                             'from_':self.latest_block,
+                                                             'to_': self.current_block})
 
             # We parse only blocks with transactions
-            parsed_blocks = reversed(range(self.latest_block + 1,
-                                               current_block + 1))
-            logging.debug("Refresh from {0} to {1}".format(self.latest_block + 1,
-                                               current_block + 1))
-            parsed_blocks = [n for n in parsed_blocks
-                             if n in with_tx['result']['blocks']]
-            logging.debug(parsed_blocks)
-            self.wallet.refresh_progressed.emit(self.latest_block, current_block)
-
-            for block_number in parsed_blocks:
-                self._parse_block(community, block_number, received_list)
-                self.wallet.refresh_progressed.emit(current_block - block_number,
-                                                     current_block - self.latest_block)
+            for (txid, txdata) in enumerate(tx_history['history']['received'] + tx_history['history']['sent']):
+                self._parse_transaction(community, txdata, received_list, txid)
 
             if current_block > self.latest_block:
                 self.available_sources = self.wallet.sources(community)
@@ -397,12 +364,12 @@ class Wallet(QObject):
         logging.debug("Sender pubkey:{0}".format(key.pubkey))
 
         try:
-            issuer_uid = Person.lookup(key.pubkey, community).uid
+            issuer_uid = self.identities_registry.lookup(key.pubkey, community).uid
         except LookupFailureError:
             issuer_uid = ""
 
         try:
-            receiver_uid = Person.lookup(recipient, community).uid
+            receiver_uid = self.identities_registry.lookup(recipient, community).uid
         except LookupFailureError:
             receiver_uid = ""