Serialize the transaction

Author: 15Dkatz

backend/app/__init__.py

@@ -2,13 +2,16 @@
 import requests
 import random
 
-from flask import Flask, jsonify
+from flask import Flask, jsonify, request
 
 from backend.blockchain.blockchain import Blockchain
+from backend.wallet.wallet import Wallet
+from backend.wallet.transaction import Transaction
 from backend.pubsub import PubSub
 
 app = Flask(__name__)
 blockchain = Blockchain()
+wallet = Wallet()
 pubsub = PubSub(blockchain)
 
 @app.route('/')
@@ -30,6 +33,19 @@ def route_blockchain_mine():
 
     return jsonify(block.to_json())
 
+@app.route('/wallet/transact', methods=['POST'])
+def route_wallet_transact():
+    transaction_data = request.get_json()
+    transaction = Transaction(
+        wallet,
+        transaction_data['recipient'],
+        transaction_data['amount']
+    )
+
+    print(f'transaction.to_json(): {transaction.to_json()}')
+
+    return jsonify(transaction.to_json())
+
 ROOT_PORT = 5000
 PORT = ROOT_PORT
 

backend/wallet/transaction.py

@@ -60,6 +60,12 @@ def update(self, sender_wallet, recipient, amount):
 
         self.input = self.create_input(sender_wallet, self.output)
 
+    def to_json(self):
+        """
+        Serialize the transaction.
+        """
+        return self.__dict__
+
     @staticmethod
     def is_valid_transaction(transaction):
         """

backend/wallet/wallet.py

@@ -4,7 +4,11 @@
 from backend.config import STARTING_BALANCE
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives.asymmetric import ec
-from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric.utils import (
+    encode_dss_signature,
+    decode_dss_signature
+)
+from cryptography.hazmat.primitives import hashes, serialization
 from cryptography.exceptions import InvalidSignature
 
 class Wallet:
@@ -21,24 +25,41 @@ def __init__(self):
             default_backend()
         )
         self.public_key = self.private_key.public_key()
+        self.serialize_public_key()
 
     def sign(self, data):
         """
         Generate a signature based on the data using the local private key.
         """
-        return self.private_key.sign(
+        return decode_dss_signature(self.private_key.sign(
             json.dumps(data).encode('utf-8'),
             ec.ECDSA(hashes.SHA256())
-        )
+        ))
+
+    def serialize_public_key(self):
+        """
+        Reset the public key to its serialized version.
+        """
+        self.public_key = self.public_key.public_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PublicFormat.SubjectPublicKeyInfo
+        ).decode('utf-8')
 
     @staticmethod
     def verify(public_key, data, signature):
         """
         Verify a signature based on the original public key and data.
         """
+        deserialized_public_key = serialization.load_pem_public_key(
+            public_key.encode('utf-8'),
+            default_backend()
+        )
+
+        (r, s) = signature
+
         try:
-            public_key.verify(
-                signature,
+            deserialized_public_key.verify(
+                encode_dss_signature(r, s),
                 json.dumps(data).encode('utf-8'),
                 ec.ECDSA(hashes.SHA256())    
             )