Complete Section: Transactions on the Network

Author: 15Dkatz

backend/app/__init__.py

@@ -7,12 +7,14 @@
 from backend.blockchain.blockchain import Blockchain
 from backend.wallet.wallet import Wallet
 from backend.wallet.transaction import Transaction
+from backend.wallet.transaction_pool import TransactionPool
 from backend.pubsub import PubSub
 
 app = Flask(__name__)
 blockchain = Blockchain()
 wallet = Wallet()
-pubsub = PubSub(blockchain)
+transaction_pool = TransactionPool()
+pubsub = PubSub(blockchain, transaction_pool)
 
 @app.route('/')
 def route_default():
@@ -36,13 +38,22 @@ def route_blockchain_mine():
 @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()}')
+    transaction = transaction_pool.existing_transaction(wallet.address)
+
+    if transaction:
+        transaction.update(
+            wallet,
+            transaction_data['recipient'],
+            transaction_data['amount']
+        )
+    else:
+        transaction = Transaction(
+            wallet,
+            transaction_data['recipient'],
+            transaction_data['amount']
+        )
+
+    pubsub.broadcast_transaction(transaction)
 
     return jsonify(transaction.to_json())
 

backend/pubsub.py

@@ -5,19 +5,22 @@
 from pubnub.callbacks import SubscribeCallback
 
 from backend.blockchain.block import Block
+from backend.wallet.transaction import Transaction
 
 pnconfig = PNConfiguration()
 pnconfig.subscribe_key = 'sub-c-666638f6-ec63-11e9-b715-9abbdb5d0da2'
 pnconfig.publish_key = 'pub-c-82bf7695-ce5e-4bc5-9cd9-a8f8147dc2a8'
 
 CHANNELS = {
     'TEST': 'TEST',
-    'BLOCK': 'BLOCK'
+    'BLOCK': 'BLOCK',
+    'TRANSACTION': 'TRANSACTION'
 }
 
 class Listener(SubscribeCallback):
-    def __init__(self, blockchain):
+    def __init__(self, blockchain, transaction_pool):
         self.blockchain = blockchain
+        self.transaction_pool = transaction_pool
 
     def message(self, pubnub, message_object):
         print(f'\n-- Channel: {message_object.channel} | Message: {message_object.message}')
@@ -32,16 +35,20 @@ def message(self, pubnub, message_object):
                 print('\n -- Successfully replaced the local chain')
             except Exception as e:
                 print(f'\n -- Did not replace chain: {e}')
+        elif message_object.channel == CHANNELS['TRANSACTION']:
+            transaction = Transaction.from_json(message_object.message)
+            self.transaction_pool.set_transaction(transaction)
+            print('\n -- Set the new transaction in the transaction pool')
 
 class PubSub():
     """
     Handles the publish/subscribe layer of the application.
     Provides communication between the nodes of the blockchain network.
     """
-    def __init__(self, blockchain):
+    def __init__(self, blockchain, transaction_pool):
         self.pubnub = PubNub(pnconfig)
         self.pubnub.subscribe().channels(CHANNELS.values()).execute()
-        self.pubnub.add_listener(Listener(blockchain))
+        self.pubnub.add_listener(Listener(blockchain, transaction_pool))
 
     def publish(self, channel, message):
         """
@@ -55,6 +62,12 @@ def broadcast_block(self, block):
         """
         self.publish(CHANNELS['BLOCK'], block.to_json())
 
+    def broadcast_transaction(self, transaction):
+        """
+        Broadcast a transaction to all nodes.
+        """
+        self.publish(CHANNELS['TRANSACTION'], transaction.to_json())
+
 def main():
     pubsub = PubSub()
 

backend/tests/wallet/test_transaction_pool.py

@@ -0,0 +1,10 @@
+from backend.wallet.transaction_pool import TransactionPool
+from backend.wallet.transaction import Transaction
+from backend.wallet.wallet import Wallet
+
+def test_set_transaction():
+    transaction_pool = TransactionPool()
+    transaction = Transaction(Wallet(), 'recipient', 1)
+    transaction_pool.set_transaction(transaction)
+
+    assert transaction_pool.transaction_map[transaction.id] == transaction

backend/wallet/transaction.py

@@ -8,14 +8,22 @@ class Transaction:
     Document of an exchange in currency from a sender to one
     or more recipients.
     """
-    def __init__(self, sender_wallet, recipient, amount):
-        self.id = str(uuid.uuid4())[0:8]
-        self.output = self.create_output(
+    def __init__(
+        self,
+        sender_wallet=None,
+        recipient=None,
+        amount=None,
+        id=None,
+        output=None,
+        input=None
+    ):
+        self.id = id or str(uuid.uuid4())[0:8]
+        self.output = output or self.create_output(
             sender_wallet,
             recipient,
             amount
         )
-        self.input = self.create_input(sender_wallet, self.output)
+        self.input = input or self.create_input(sender_wallet, self.output)
 
     def create_output(self, sender_wallet, recipient, amount):
         """
@@ -66,6 +74,14 @@ def to_json(self):
         """
         return self.__dict__
 
+    @staticmethod
+    def from_json(transaction_json):
+        """
+        Deserialize a transaction's json representation back into a
+        Transaction instance
+        """
+        return Transaction(**transaction_json)
+
     @staticmethod
     def is_valid_transaction(transaction):
         """
@@ -88,5 +104,9 @@ def main():
     transaction = Transaction(Wallet(), 'recipient', 15)
     print(f'transaction.__dict__: {transaction.__dict__}')
 
+    transaction_json = transaction.to_json()
+    restored_transaction = Transaction.from_json(transaction_json)
+    print(f'restored_transaction.__dict__: {restored_transaction.__dict__}')
+
 if __name__ == '__main__':
     main()

backend/wallet/transaction_pool.py

@@ -0,0 +1,18 @@
+class TransactionPool:
+    def __init__(self):
+        self.transaction_map = {}
+
+    def set_transaction(self, transaction):
+        """
+        Set a transaction in the transaction pool.
+        """
+        self.transaction_map[transaction.id] = transaction
+
+
+    def existing_transaction(self, address):
+        """
+        Find a transaction generated by the address in the transaction pool
+        """
+        for transaction in self.transaction_map.values():
+            if transaction.input['address'] == address:
+                return transaction