Merge branch 'master' into market_listeners_tests

Author: Tom Galloway

api/restapi.py

@@ -18,7 +18,7 @@
 from twisted.protocols.basic import FileSender
 
 from config import DATA_FOLDER, RESOLVER, LIBBITCOIN_SERVER_TESTNET, LIBBITCOIN_SERVER, \
-    set_value, get_value, str_to_bool
+    set_value, get_value, str_to_bool, TRANSACTION_FEE
 from protos.countries import CountryCode
 from protos import objects
 from keys import blockchainid
@@ -858,7 +858,8 @@ def get_settings(self, request):
                 "terms_conditions": "" if settings[9] is None else settings[9],
                 "refund_policy": "" if settings[10] is None else settings[10],
                 "resolver": get_value("CONSTANTS", "RESOLVER"),
-                "network_connection": nat_type
+                "network_connection": nat_type,
+                "transaction_fee": TRANSACTION_FEE
             }
             mods = []
             try:

db/datastore.py

@@ -562,8 +562,17 @@ def get_conversations(self):
 WHERE guid=? and messageType=?''', (g[0], "CHAT"))
             val = cursor.fetchone()
             if val[0] is not None:
+                avatar_hash = None
+                try:
+                    with open(DATA_FOLDER + 'cache/' + g[0], "r") as filename:
+                        profile = filename.read()
+                    p = objects.Profile()
+                    p.ParseFromString(profile)
+                    avatar_hash = p.avatar_hash.encode("hex")
+                except Exception:
+                    pass
                 ret.append({"guid": g[0],
-                            "avatar_hash": val[0].encode("hex"),
+                            "avatar_hash": avatar_hash,
                             "last_message": val[1],
                             "timestamp": val[2],
                             "public_key": val[3].encode("hex"),
@@ -842,7 +851,7 @@ def get_all(self):
     def get_unfunded(self):
         conn = Database.connect_database(self.PATH)
         cursor = conn.cursor()
-        cursor.execute('''SELECT id FROM purchases WHERE status=0''')
+        cursor.execute('''SELECT id, timestamp FROM purchases WHERE status=0''')
         ret = cursor.fetchall()
         conn.close()
         return ret

dht/protocol.py

@@ -224,7 +224,7 @@ def handleCallResponse(self, result, node):
         we get no response, make sure it's removed from the routing table.
         """
         if result[0]:
-            if self.router.isNewNode(node):
+            if self.isNewConnection(node):
                 self.log.debug("Call response from new node, transferring key/values")
                 reactor.callLater(1, self.transferKeyValues, node)
             self.router.addContact(node)
@@ -239,11 +239,17 @@ def addToRouter(self, node):
         We add the node to our router and transfer our stored values
         if they are new and within our neighborhood.
         """
-        if self.router.isNewNode(node):
+        if self.isNewConnection(node):
             self.log.debug("Found a new node, transferring key/values")
             reactor.callLater(1, self.transferKeyValues, node)
         self.router.addContact(node)
 
+    def isNewConnection(self, node):
+        if (node.ip, node.port) in self.multiplexer:
+            return self.multiplexer[(node.ip, node.port)].handler.check_new_connection()
+        else:
+            return False
+
     def __iter__(self):
         return iter(self.handled_commands)
 

dht/tests/test_protocol.py

@@ -15,7 +15,6 @@
 from dht.protocol import KademliaProtocol
 from dht.utils import digest
 from dht.storage import ForgetfulStorage
-from dht.tests.utils import mknode
 from dht.node import Node
 from protos import message, objects
 from net.wireprotocol import OpenBazaarProtocol
@@ -613,7 +612,7 @@ def _connecting_to_connected(self):
         self.next_seqnum = seqnum + 1
 
     def test_badRPCDelete(self):
-        n = mknode()
+        n = Node(digest("S"), self.addr1[0], self.addr1[1])
         val = self.protocol.rpc_delete(n, 'testkeyword', 'key', 'testsig')
         self.assertEqual(val, ["False"])
         val = self.protocol.rpc_delete(n, '', '', '')

market/contracts.py

@@ -14,7 +14,7 @@
 from bitcoin.core.script import CScript, OP_2, OP_3, OP_CHECKMULTISIG
 from bitcoin.wallet import P2SHBitcoinAddress, P2PKHBitcoinAddress
 from collections import OrderedDict
-from config import DATA_FOLDER
+from config import DATA_FOLDER, TRANSACTION_FEE
 from copy import deepcopy
 from datetime import datetime
 from dht.utils import digest
@@ -410,6 +410,9 @@ def add_purchase_info(self,
                         shipping_amount = float("{0:.8f}".format(float(price) / float(conversion_rate))) * quantity
                 amount_to_pay += shipping_amount
 
+        if round(amount_to_pay, 8) < round(TRANSACTION_FEE / float(100000000), 8):
+            raise Exception("Contract price is below transaction fee.")
+
         order_json["buyer_order"]["order"]["payment"]["amount"] = round(amount_to_pay, 8)
         self.contract["buyer_order"] = order_json["buyer_order"]
 
@@ -483,7 +486,7 @@ def add_order_confirmation(self,
             vendor_priv = derive_childkey(masterkey_v, chaincode, bitcointools.MAINNET_PRIVATE)
             tx.sign(vendor_priv)
             tx.broadcast(self.blockchain)
-            self.log.info("Broadcasting payout tx %s to network" % tx.get_hash())
+            self.log.info("broadcasting payout tx %s to network" % tx.get_hash())
             self.db.sales.update_payment_tx(order_id, tx.get_hash())
 
         confirmation = json.dumps(conf_json["vendor_order_confirmation"]["invoice"], indent=4)
@@ -631,7 +634,7 @@ def add_receipt(self,
             receipt_json["buyer_receipt"]["receipt"]["payout"] = {}
             if tx.multisign(signatures, redeem_script):
                 tx.broadcast(self.blockchain)
-                self.log.info("Broadcasting payout tx %s to network" % tx.get_hash())
+                self.log.info("broadcasting payout tx %s to network" % tx.get_hash())
                 receipt_json["buyer_receipt"]["receipt"]["payout"]["txid"] = tx.get_hash()
 
             receipt_json["buyer_receipt"]["receipt"]["payout"]["signature(s)"] = buyer_signatures
@@ -721,7 +724,7 @@ def accept_receipt(self, notification_listener, blockchain, receipt_json=None):
 
             tx.multisign(signatures, redeem_script)
             tx.broadcast(self.blockchain)
-            self.log.info("Broadcasting payout tx %s to network" % tx.get_hash())
+            self.log.info("broadcasting payout tx %s to network" % tx.get_hash())
 
             self.db.sales.update_payment_tx(order_id, tx.get_hash())
 
@@ -964,6 +967,60 @@ def save(self):
         # save the `ListingMetadata` protobuf to the database as well
         self.db.listings.add_listing(data)
 
+    def process_refund(self, refund_json, blockchain, notification_listener):
+        self.contract["refund"] = refund_json["refund"]
+        order_id = refund_json["refund"]["order_id"]
+
+        if "txid" not in refund_json["refund"]:
+            outpoints = json.loads(self.db.purchases.get_outpoint(order_id))
+            refund_address = self.contract["buyer_order"]["order"]["refund_address"]
+            redeem_script = self.contract["buyer_order"]["order"]["payment"]["redeem_script"]
+            value = int(float(refund_json["refund"]["value"]) * 100000000)
+            tx = BitcoinTransaction.make_unsigned(outpoints, refund_address,
+                                                  testnet=self.testnet,
+                                                  out_value=value)
+            chaincode = self.contract["buyer_order"]["order"]["payment"]["chaincode"]
+            masterkey_b = bitcointools.bip32_extract_key(KeyChain(self.db).bitcoin_master_privkey)
+            buyer_priv = derive_childkey(masterkey_b, chaincode, bitcointools.MAINNET_PRIVATE)
+            buyer_sigs = tx.create_signature(buyer_priv, redeem_script)
+            vendor_sigs = refund_json["refund"]["signature(s)"]
+
+            signatures = []
+            for i in range(len(outpoints)):
+                for vendor_sig in vendor_sigs:
+                    if vendor_sig["index"] == i:
+                        v_signature = vendor_sig["signature"]
+                for buyer_sig in buyer_sigs:
+                    if buyer_sig["index"] == i:
+                        b_signature = buyer_sig["signature"]
+                signature_obj = {"index": i, "signatures": [b_signature, v_signature]}
+                signatures.append(signature_obj)
+
+            tx.multisign(signatures, redeem_script)
+            tx.broadcast(blockchain)
+            self.log.info("broadcasting refund tx %s to network" % tx.get_hash())
+
+        self.db.sales.update_status(order_id, 7)
+        file_path = DATA_FOLDER + "purchases/trade receipts/" + order_id + ".json"
+        with open(file_path, 'w') as outfile:
+            outfile.write(json.dumps(self.contract, indent=4))
+        file_path = DATA_FOLDER + "purchases/in progress/" + order_id + ".json"
+        if os.path.exists(file_path):
+            os.remove(file_path)
+
+        title = self.contract["vendor_offer"]["listing"]["item"]["title"]
+        if "image_hashes" in self.contract["vendor_offer"]["listing"]["item"]:
+            image_hash = unhexlify(self.contract["vendor_offer"]["listing"]["item"]["image_hashes"][0])
+        else:
+            image_hash = ""
+        buyer_guid = self.contract["buyer_order"]["order"]["id"]["guid"]
+        if "blockchain_id" in self.contract["buyer_order"]["order"]["id"]:
+            handle = self.contract["buyer_order"]["order"]["id"]["blockchain_id"]
+        else:
+            handle = ""
+        notification_listener.notify(buyer_guid, handle, "refund", order_id, title, image_hash)
+
+
     def verify(self, sender_key):
         """
         Validate that an order sent over by a buyer is filled out correctly.

market/network.py

@@ -11,7 +11,6 @@
 import nacl.utils
 import obelisk
 import os.path
-import pickle
 import time
 from binascii import unhexlify
 from collections import OrderedDict
@@ -197,6 +196,7 @@ def get_result(result):
                     self.get_image(node_to_ask, p.avatar_hash)
                 if not os.path.isfile(DATA_FOLDER + 'cache/' + p.header_hash.encode("hex")):
                     self.get_image(node_to_ask, p.header_hash)
+                self.cache(result[1][0], node_to_ask.id.encode("hex"))
                 return p
             except Exception:
                 return None
@@ -563,6 +563,12 @@ def parse_messages(messages):
                                               self.db, self.protocol.get_message_listener(),
                                               self.protocol.get_notification_listener(),
                                               self.protocol.multiplexer.testnet)
+                            elif p.type == objects.PlaintextMessage.Type.Value("REFUND"):
+                                refund_json = json.loads(p.message, object_pairs_hook=OrderedDict)
+                                c = Contract(self.db, hash_value=unhexlify(refund_json["refund"]["order_id"]),
+                                             testnet=self.protocol.multiplexer.testnet)
+                                c.process_refund(refund_json, self.protocol.multiplexer.blockchain,
+                                                 self.protocol.get_notification_listener())
                             else:
                                 listener.notify(p, signature)
                         except Exception:
@@ -833,16 +839,20 @@ def history_fetched(ec, history):
 
                 outputs.append({'value': moderator_fee, 'address': moderator_address})
                 dispute_json["dispute_resolution"]["resolution"]["moderator_address"] = moderator_address
-                dispute_json["dispute_resolution"]["resolution"]["moderator_fee"] = moderator_fee
-                dispute_json["dispute_resolution"]["resolution"]["transaction_fee"] = TRANSACTION_FEE
+                dispute_json["dispute_resolution"]["resolution"]["moderator_fee"] = \
+                    round(moderator_fee / float(100000000), 8)
+                dispute_json["dispute_resolution"]["resolution"]["transaction_fee"] = \
+                    round(TRANSACTION_FEE / float(100000000), 8)
                 if float(buyer_percentage) > 0:
                     amt = int(float(buyer_percentage) * satoshis)
-                    dispute_json["dispute_resolution"]["resolution"]["buyer_payout"] = amt
+                    dispute_json["dispute_resolution"]["resolution"]["buyer_payout"] = \
+                        round(amt / float(100000000), 8)
                     outputs.append({'value': amt,
                                     'address': buyer_address})
                 if float(vendor_percentage) > 0:
                     amt = int(float(vendor_percentage) * satoshis)
-                    dispute_json["dispute_resolution"]["resolution"]["vendor_payout"] = amt
+                    dispute_json["dispute_resolution"]["resolution"]["vendor_payout"] = \
+                        round(amt / float(100000000), 8)
                     outputs.append({'value': amt,
                                     'address': vendor_address})
 
@@ -902,32 +912,34 @@ def release_funds(self, order_id):
         the moderator has resolved the dispute and provided his signature.
         """
         if os.path.exists(DATA_FOLDER + "purchases/in progress/" + order_id + ".json"):
-            file_path = DATA_FOLDER + "purchases/trade receipts/" + order_id + ".json"
-            outpoints = pickle.loads(self.db.purchases.get_outpoint(order_id))
+            file_path = DATA_FOLDER + "purchases/in progress/" + order_id + ".json"
+            outpoints = json.loads(self.db.purchases.get_outpoint(order_id))
         elif os.path.exists(DATA_FOLDER + "store/contracts/in progress/" + order_id + ".json"):
             file_path = DATA_FOLDER + "store/contracts/in progress/" + order_id + ".json"
-            outpoints = pickle.loads(self.db.sales.get_outpoint(order_id))
+            outpoints = json.loads(self.db.sales.get_outpoint(order_id))
 
         with open(file_path, 'r') as filename:
             contract = json.load(filename, object_pairs_hook=OrderedDict)
 
-        vendor_address = contract["vendor_order_confirmation"]["invoice"]["payout"]["address"]
-        buyer_address = contract["buyer_order"]["order"]["refund_address"]
-
         outputs = []
 
-        outputs.append({'value': int(contract["dispute_resolution"]["resolution"]["moderator_fee"]),
+        outputs.append({'value': int(float(contract["dispute_resolution"]
+                                           ["resolution"]["moderator_fee"]) * 100000000),
                         'address': contract["dispute_resolution"]["resolution"]["moderator_address"]})
 
         if "buyer_payout" in contract["dispute_resolution"]["resolution"]:
-            outputs.append({'value': int(contract["dispute_resolution"]["resolution"]["buyer_payout"]),
+            buyer_address = contract["buyer_order"]["order"]["refund_address"]
+            outputs.append({'value': int(float(contract["dispute_resolution"]
+                                               ["resolution"]["buyer_payout"]) * 100000000),
                             'address': buyer_address})
 
         if "vendor_payout" in contract["dispute_resolution"]["resolution"]:
-            outputs.append({'value': int(contract["dispute_resolution"]["resolution"]["vendor_payout"]),
+            vendor_address = contract["vendor_order_confirmation"]["invoice"]["payout"]["address"]
+            outputs.append({'value': int(float(contract["dispute_resolution"]
+                                               ["resolution"]["vendor_payout"]) * 100000000),
                             'address': vendor_address})
 
-        tx = BitcoinTransaction.make_unsigned(outpoints, outputs)
+        tx = BitcoinTransaction.make_unsigned(outpoints, outputs, testnet=self.protocol.multiplexer.testnet)
         chaincode = contract["buyer_order"]["order"]["payment"]["chaincode"]
         redeem_script = str(contract["buyer_order"]["order"]["payment"]["redeem_script"])
         masterkey = bitcointools.bip32_extract_key(KeyChain(self.db).bitcoin_master_privkey)
@@ -948,7 +960,7 @@ def release_funds(self, order_id):
 
         tx.multisign(signatures, redeem_script)
         tx.broadcast(self.protocol.multiplexer.blockchain)
-        self.log.info("Broadcasting payout tx %s to network" % tx.get_hash())
+        self.log.info("broadcasting payout tx %s to network" % tx.get_hash())
 
         if self.db.purchases.get_purchase(order_id) is not None:
             self.db.purchases.update_status(order_id, 6)
@@ -986,8 +998,6 @@ def get_result(result):
                         pass
                 return ret
             except Exception:
-                import traceback
-                traceback.print_exc()
                 return None
 
         if node_to_ask.ip is None:
@@ -1004,7 +1014,7 @@ def refund(self, order_id):
         to the buyer with contain the signature.
         """
         file_path = DATA_FOLDER + "store/contracts/in progress/" + order_id + ".json"
-        outpoints = pickle.loads(self.db.sales.get_outpoint(order_id))
+        outpoints = json.loads(self.db.sales.get_outpoint(order_id))
 
         with open(file_path, 'r') as filename:
             contract = json.load(filename, object_pairs_hook=OrderedDict)
@@ -1014,7 +1024,6 @@ def refund(self, order_id):
             contract["buyer_order"]["order"]["id"]["pubkeys"]["guid"],
             encoder=nacl.encoding.HexEncoder).to_curve25519_public_key()
         refund_address = contract["buyer_order"]["order"]["refund_address"]
-        redeem_script = contract["buyer_order"]["order"]["payment"]["redeem_script"]
         tx = BitcoinTransaction.make_unsigned(outpoints, refund_address,
                                               testnet=self.protocol.multiplexer.testnet)
         chaincode = contract["buyer_order"]["order"]["payment"]["chaincode"]
@@ -1024,14 +1033,25 @@ def refund(self, order_id):
         refund_json = {"refund": {}}
         refund_json["refund"]["order_id"] = order_id
         if "moderator" in contract["buyer_order"]["order"]:
+            redeem_script = contract["buyer_order"]["order"]["payment"]["redeem_script"]
             sigs = tx.create_signature(vendor_priv, redeem_script)
-            refund_json["refund"]["value"] = tx.get_out_value()
+            refund_json["refund"]["value"] = round(tx.get_out_value() / float(100000000), 8)
             refund_json["refund"]["signature(s)"] = sigs
         else:
             tx.sign(vendor_priv)
             tx.broadcast(self.protocol.multiplexer.blockchain)
+            self.log.info("broadcasting refund tx %s to network" % tx.get_hash())
             refund_json["refund"]["txid"] = tx.get_hash()
 
+        contract["refund"] = refund_json["refund"]
+        self.db.sales.update_status(order_id, 7)
+        file_path = DATA_FOLDER + "store/contracts/trade receipts/" + order_id + ".json"
+        with open(file_path, 'w') as outfile:
+            outfile.write(json.dumps(contract, indent=4))
+        file_path = DATA_FOLDER + "store/contracts/in progress/" + order_id + ".json"
+        if os.path.exists(file_path):
+            os.remove(file_path)
+
         def get_node(node_to_ask):
             def parse_response(response):
                 if not response[0]:
@@ -1059,8 +1079,7 @@ def parse_response(response):
     @staticmethod
     def cache(file_to_save, filename):
         """
-        Saves the file to a cache folder if it doesn't already exist.
+        Saves the file to a cache folder override previous versions if any.
         """
-        if not os.path.isfile(DATA_FOLDER + "cache/" + filename):
-            with open(DATA_FOLDER + "cache/" + filename, 'wb') as outfile:
-                outfile.write(file_to_save)
+        with open(DATA_FOLDER + "cache/" + filename, 'wb') as outfile:
+            outfile.write(file_to_save)