Merge remote-tracking branch 'upstream/master'

Author: Tom Galloway

market/moderation.py

@@ -143,7 +143,7 @@ def close_dispute(resolution_json, db, message_listener, notification_listener,
     order_id = resolution_json["dispute_resolution"]["resolution"]["order_id"]
 
     if os.path.exists(DATA_FOLDER + "purchases/in progress/" + order_id + ".json"):
-        file_path = DATA_FOLDER + "purchases/trade receipts/" + order_id + ".json"
+        file_path = DATA_FOLDER + "purchases/in progress/" + order_id + ".json"
     elif os.path.exists(DATA_FOLDER + "store/contracts/in progress/" + order_id + ".json"):
         file_path = DATA_FOLDER + "store/contracts/in progress/" + order_id + ".json"
 
@@ -157,9 +157,11 @@ def close_dispute(resolution_json, db, message_listener, notification_listener,
             moderator_pubkey = unhexlify(moderator["pubkeys"]["guid"])
             moderator_avatar = unhexlify(moderator["avatar"])
 
+    print json.dumps(resolution_json, indent=4)
+
     verify_key = nacl.signing.VerifyKey(moderator_pubkey)
     verify_key.verify(json.dumps(resolution_json["dispute_resolution"]["resolution"], indent=4),
-                      resolution_json["dispute_resolution"]["signature"])
+                      base64.b64decode(resolution_json["dispute_resolution"]["signature"]))
 
     contract["dispute_resolution"] = resolution_json["dispute_resolution"]
 

market/network.py

@@ -22,7 +22,7 @@
 from keys.keychain import KeyChain
 from log import Logger
 from market.contracts import Contract
-from market.moderation import process_dispute
+from market.moderation import process_dispute, close_dispute
 from market.profile import Profile
 from market.protocol import MarketProtocol
 from market.transactions import BitcoinTransaction
@@ -559,6 +559,11 @@ 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("DISPUTE_CLOSE"):
+                                close_dispute(json.loads(p.message, object_pairs_hook=OrderedDict),
+                                              self.db, self.protocol.get_message_listener(),
+                                              self.protocol.get_notification_listener(),
+                                              self.protocol.multiplexer.testnet)
                             else:
                                 listener.notify(p, signature)
                         except Exception:
@@ -854,7 +859,7 @@ def history_fetched(ec, history):
                     dispute_json["dispute_resolution"]["resolution"]["decision"] = resolution
                     dispute_json["dispute_resolution"]["signature"] = \
                         base64.b64encode(KeyChain(self.db).signing_key.sign(json.dumps(
-                            dispute_json["dispute_resolution"]["resolution"]))[:64])
+                            dispute_json["dispute_resolution"]["resolution"], indent=4))[:64])
 
                     def get_node(node_to_ask, recipient_guid, public_key):
                         def parse_response(response):
@@ -904,48 +909,41 @@ def release_funds(self, order_id):
         vendor_address = contract["vendor_order_confirmation"]["invoice"]["payout"]["address"]
         buyer_address = contract["buyer_order"]["order"]["refund_address"]
 
-        for moderator in contract["vendor_offer"]["listing"]["moderators"]:
-            if moderator["guid"] == contract["buyer_order"]["order"]["moderator"]:
-                masterkey_m = moderator["pubkeys"]["bitcoin"]["key"]
-
         outputs = []
 
-        outputs.append({'value': contract["dispute_resolution"]["resolution"]["moderator_fee"],
+        outputs.append({'value': int(contract["dispute_resolution"]["resolution"]["moderator_fee"]),
                         'address': contract["dispute_resolution"]["resolution"]["moderator_address"]})
 
         if "buyer_payout" in contract["dispute_resolution"]["resolution"]:
-            outputs.append({'value': contract["dispute_resolution"]["resolution"]["buyer_payout"],
+            outputs.append({'value': int(contract["dispute_resolution"]["resolution"]["buyer_payout"]),
                             'address': buyer_address})
 
         if "vendor_payout" in contract["dispute_resolution"]["resolution"]:
-            outputs.append({'value': contract["dispute_resolution"]["resolution"]["vendor_payout"],
+            outputs.append({'value': int(contract["dispute_resolution"]["resolution"]["vendor_payout"]),
                             'address': vendor_address})
 
-        tx = bitcointools.mktx(outpoints, outputs)
-        signatures = []
+        tx = BitcoinTransaction.make_unsigned(outpoints, outputs)
         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)
         childkey = derive_childkey(masterkey, chaincode, bitcointools.MAINNET_PRIVATE)
 
-        mod_key = derive_childkey(masterkey_m, chaincode)
+        own_sig = tx.create_signature(childkey, redeem_script)
 
-        valid_inputs = 0
+        signatures = []
         for index in range(0, len(outpoints)):
-            sig = bitcointools.multisign(tx, index, redeem_script, childkey)
-            signatures.append({"input_index": index, "signature": sig})
+            sig_ob = {"index": index, "signatures": []}
+            for s in own_sig:
+                if int(s["index"]) == index:
+                    sig_ob["signatures"].append(s["signature"])
             for s in contract["dispute_resolution"]["resolution"]["tx_signatures"]:
-                if s["input_index"] == index:
-                    if bitcointools.verify_tx_input(tx, index, redeem_script, s["signature"], mod_key):
-                        tx = bitcointools.apply_multisignatures(tx, index, str(redeem_script),
-                                                                sig, str(s["signature"]))
-                        valid_inputs += 1
-
-        if valid_inputs == len(outpoints):
-            self.log.info("Broadcasting payout tx %s to network" % bitcointools.txhash(tx))
-            self.protocol.multiplexer.blockchain.broadcast(tx)
-        else:
-            raise Exception("Failed to reconstruct transaction with moderator signature.")
+                if int(s["index"]) == index:
+                    sig_ob["signatures"].append(s["signature"])
+            signatures.append(sig_ob)
+
+        tx.multisign(signatures, redeem_script)
+        tx.broadcast(self.protocol.multiplexer.blockchain)
+        self.log.info("Broadcasting payout tx %s to network" % tx.get_hash())
 
     def get_ratings(self, node_to_ask, listing_hash=None):
         """

market/protocol.py

@@ -317,9 +317,9 @@ def rpc_dispute_open(self, sender, pubkey, encrypted):
     def rpc_dispute_close(self, sender, pubkey, encrypted):
         try:
             box = Box(self.signing_key.to_curve25519_private_key(), PublicKey(pubkey))
-            order = box.decrypt(encrypted)
-            contract = json.loads(order, object_pairs_hook=OrderedDict)
-            close_dispute(contract, self.db, self.get_message_listener(),
+            res = box.decrypt(encrypted)
+            resolution_json = json.loads(res, object_pairs_hook=OrderedDict)
+            close_dispute(resolution_json, self.db, self.get_message_listener(),
                           self.get_notification_listener(), self.multiplexer.testnet)
             self.router.addContact(sender)
             self.log.info("Contract dispute closed by %s" % sender)
@@ -411,7 +411,7 @@ def callDisputeOpen(self, nodeToAsk, ephem_pubkey, encrypted_contract):
         return d.addCallback(self.handleCallResponse, nodeToAsk)
 
     def callDisputeClose(self, nodeToAsk, ephem_pubkey, encrypted_contract):
-        d = self.dispute_open(nodeToAsk, ephem_pubkey, encrypted_contract)
+        d = self.dispute_close(nodeToAsk, ephem_pubkey, encrypted_contract)
         return d.addCallback(self.handleCallResponse, nodeToAsk)
 
     def callGetRatings(self, nodeToAsk, listing_hash=None):