Package more neatly the encoding / decoding

Author: gdanezis

rsc.py

@@ -1,6 +1,6 @@
 #!/usr/bin/python
 from rscoin.rscservice import RSCProtocol, RSCFactory, load_setup, unpackage_commit_response, get_authorities, \
-                    package_query, unpackage_query_response, package_commit, unpackage_commit_response
+                    package_query, unpackage_query_response, package_commit, package_issue, unpackage_commit_response
 
 import rscoin
 from base64 import b64encode, b64decode
@@ -393,9 +393,11 @@ def play_another_song(var):
         sig = mykey.sign(tx.id())
 
         ## Now we test the Commit
-        tx_ser = tx.serialize()
-        core = map(b64encode, [tx_ser, mykey.pub.export(), sig])
-        data = " ".join(["Commit", str(len(core))] + core)
+        #tx_ser = tx.serialize()
+        #core = map(b64encode, [tx_ser, mykey.pub.export(), sig])
+        #data = " ".join(["Commit", str(len(core))] + core)
+
+        data = package_issue(tx, [mykey, sig])
 
         if args.mock:
             print data

rscoin/rscservice.py

@@ -43,7 +43,7 @@ def package_query(tx, tx_deps, keys):
     dataCore = map(b64encode, items)    
 
     H = sha256(" ".join(dataCore)).digest()
-    data = " ".join(["Query", str(len(dataCore))] + dataCore)
+    data = " ".join(["xQuery", str(len(dataCore))] + dataCore)
 
     return H, data, dataCore
 
@@ -57,14 +57,24 @@ def unpackage_query_response(response):
 
     return resp
 
+
 def package_commit(core, ks_list):
     ks_flat = []
     for (k, s) in ks_list:
         ks_flat += [ k, s ]
 
-    data = " ".join(["Commit", str(len(core))] + core + map(b64encode, ks_flat))
+    data = " ".join(["xCommit", str(len(core))] + core + map(b64encode, ks_flat))
+    return data
+
+
+def package_issue(tx, ks):
+    tx_ser = tx.serialize()
+    k, s = ks
+    core = map(b64encode, [tx_ser, k.export()[0], s])
+    data = " ".join(["xCommit", str(len(core))] + core)
     return data
 
+
 def unpackage_commit_response(response):
     resp = response.strip().split(" ")
 
@@ -75,8 +85,6 @@ def unpackage_commit_response(response):
     return resp
 
 
-
-
 class RSCProtocol(LineReceiver):
 
     def __init__(self, factory):
@@ -185,11 +193,12 @@ def handle_Commit(self, items):
 
     def lineReceived(self, line):
         """ Simple de-multiplexer """
+
         items = line.split(" ")
-        if items[0] == "Query":
+        if items[0] == "xQuery":
             return self.handle_Query(items) # Get signatures           
 
-        if items[0] == "Commit":
+        if items[0] == "xCommit":
             return self.handle_Commit(items) # Seal a transaction
 
         if items[0] == "Ping":

tests/test_rscservice.py

@@ -16,7 +16,7 @@
 import rscoin
 from rscoin.rscservice import RSCFactory, load_setup, get_authorities
 from rscoin.rscservice import package_query, unpackage_query_response, \
-                        package_commit, unpackage_commit_response
+                        package_commit, package_issue, unpackage_commit_response
 
 
 
@@ -131,12 +131,13 @@ def test_TxCommit(sometx):
     for ik in tx3.get_utxo_in_keys():
         assert ik in factory.db
 
-    data1 = map(b64encode, [tx3.serialize(), tx1.serialize(), tx2.serialize(), 
-                k1.export()[0], k2.export()[0], k1.sign(tx3.id()), k2.sign(tx3.id())])
+    #data1 = map(b64encode, [tx3.serialize(), tx1.serialize(), tx2.serialize(), 
+    #            k1.export()[0], k2.export()[0], k1.sign(tx3.id()), k2.sign(tx3.id())])
 
-    H = sha256(" ".join(data1)).digest()
+    #H = sha256(" ".join(data1)).digest()
 
-    data = " ".join(["Query", str(len(data1))] + data1)
+    #data = " ".join(["Query", str(len(data1))] + data1)
+    H, data, dataCore = package_query(tx3, [tx1, tx2], [k1, k2])
 
     instance.lineReceived(data)
     response = tr.value()
@@ -148,7 +149,9 @@ def test_TxCommit(sometx):
 
     ## Now we test the Commit
     tr.clear()
-    data = " ".join(["Commit", str(len(data1))] + data1 + map(b64encode, [k, s]))
+    # data = " ".join(["Commit", str(len(dataCore))] + dataCore + map(b64encode, [k, s]))
+
+    data = package_commit(dataCore, [(k, s)])
     instance.lineReceived(data)
 
     flag, pub, sig = tr.value().split(" ")
@@ -161,29 +164,27 @@ def test_TxCommit_Issued(sometx):
     (factory, instance, tr), (k1, k2, tx1, tx2, tx3) = sometx
 
     kIssue = rscoin.Key(urandom(32), public=False)
-    pubIssue = kIssue.pub.export()
-    factory.special_key = kIssue.id() # Asssign this as the special key
+    pubIssue = kIssue.export()[0]
 
-    k1 = rscoin.Key(urandom(32), public=False)
-    k1pub = k1.pub.export()
+    factory.special_key = kIssue.id() # Asssign this as the special key
 
     tx3 = rscoin.Tx([], [rscoin.OutputTx(k1.id(), 250)])
 
     sig1 = kIssue.sign(tx3.id())
     assert tx3.check_transaction_utxo([], [pubIssue], [sig1], kIssue.id())
-
     assert tx3.check_transaction([], [pubIssue], [sig1], kIssue.id())
 
     ## Now we test the Commit
-    data1 = map(b64encode, [tx3.serialize(), pubIssue, sig1])
 
     # Ensure the entries are not in before sending message
     for k, v in tx3.get_utxo_out_entries():
         assert k not in factory.db
 
     # Send message
     tr.clear()
-    data = " ".join(["Commit", str(len(data1))] + data1)
+
+    data = package_issue(tx3, [kIssue, sig1])
+
     instance.lineReceived(data)
 
     # Ensure the returned signatures check
@@ -463,7 +464,7 @@ def test_full_client(msg_mass):
 def test_commit_error(sometx):
     (factory, instance, tr), (k1, k2, tx1, tx2, tx3) = sometx
 
-    instance.lineReceived("Commit X Y Z")
+    instance.lineReceived("xCommit X Y Z")
     assert tr.value().strip() == "Error ParsingError"
 
 @pytest.mark.online
@@ -503,8 +504,10 @@ def test_online_issue(sometx):
     sig1 = kIssue.sign(tx3.id())
 
     ## Now we test the Commit
-    data1 = map(b64encode, [tx3.serialize(), pubIssue, sig1])
-    data = " ".join(["Commit", str(len(data1))] + data1)
+    #data1 = map(b64encode, [tx3.serialize(), pubIssue, sig1])
+    #data = " ".join(["Commit", str(len(data1))] + data1)
+
+    data = package_issue(tx3, [kIssue, sig1])
 
     # test on fake
     tr.clear()