updates to support dockerization

Author: 15Dkatz

backend/app/__init__.py

@@ -8,8 +8,9 @@
 env_path = Path(__file__).parent.parent / '.env'
 load_dotenv(dotenv_path=env_path)
 
-from flask import Flask, jsonify, request
+from flask import Flask, jsonify, request, Response
 from flask_cors import CORS
+import json
 
 from backend.blockchain.blockchain import Blockchain
 from backend.wallet.wallet import Wallet
@@ -19,6 +20,18 @@
 
 app = Flask(__name__)
 CORS(app, resources={ r'/*': { 'origins': 'http://localhost:3000' } })
+
+def json_response(data, status=200):
+    """
+    Create a JSON response that preserves large integers.
+    Flask's default jsonify converts large ints to floats, which breaks
+    cryptographic signatures. This function ensures integers are preserved.
+    """
+    return Response(
+        json.dumps(data, separators=(',', ':')),
+        status=status,
+        mimetype='application/json'
+    )
 blockchain = Blockchain()
 wallet = Wallet(blockchain)
 transaction_pool = TransactionPool()
@@ -30,7 +43,7 @@ def route_default():
 
 @app.route('/blockchain')
 def route_blockchain():
-    return jsonify(blockchain.to_json())
+    return json_response(blockchain.to_json())
 
 @app.route('/blockchain/range')
 def route_blockchain_range():
@@ -53,7 +66,7 @@ def route_blockchain_mine():
     pubsub.broadcast_block(block)
     transaction_pool.clear_blockchain_transactions(blockchain)
 
-    return jsonify(block.to_json())
+    return json_response(block.to_json())
 
 @app.route('/wallet/transact', methods=['POST'])
 def route_wallet_transact():
@@ -102,7 +115,9 @@ def route_transactions():
 if os.environ.get('PEER') == 'True':
     PORT = random.randint(5051, 6000)
 
-    result = requests.get(f'http://localhost:{ROOT_PORT}/blockchain')
+    # In Docker, use service name instead of localhost
+    ROOT_HOST = os.environ.get('ROOT_BACKEND_HOST', 'localhost')
+    result = requests.get(f'http://{ROOT_HOST}:{ROOT_PORT}/blockchain')
     result_blockchain = Blockchain.from_json(result.json())
 
     try:
@@ -119,9 +134,10 @@ def route_transactions():
         ])
 
     for i in range(3):
-        transaction_pool.set_transaction(
-            Transaction(Wallet(), Wallet().address, random.randint(2, 50))
-        )
+        transaction = Transaction(Wallet(), Wallet().address, random.randint(2, 50))
+        pubsub.broadcast_transaction(transaction)
+        transaction_pool.set_transaction(transaction)
 
-app.run(port=PORT)
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=PORT, debug=True)
 

backend/pubsub.py

@@ -1,11 +1,13 @@
 import os
 import time
+import requests
 
 from pubnub.pubnub import PubNub
 from pubnub.pnconfiguration import PNConfiguration
 from pubnub.callbacks import SubscribeCallback
 
 from backend.blockchain.block import Block
+from backend.blockchain.blockchain import Blockchain
 from backend.wallet.transaction import Transaction
 
 pnconfig = PNConfiguration()
@@ -42,10 +44,38 @@ 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}')
+
+                # If we can't validate the block, try to sync the full blockchain
+                # This handles cases where we're missing previous blocks
+                self.sync_blockchain()
+
         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')
+    
+    def sync_blockchain(self):
+        """
+        Synchronize the local blockchain with the root node.
+        This is called when we receive a block we can't validate.
+        """
+        try:
+            # Get the root backend host (main node)
+            root_host = os.environ.get('ROOT_BACKEND_HOST', 'localhost')
+            root_port = os.environ.get('ROOT_PORT', '5050')
+
+            print(f'\n -- Attempting to sync blockchain from {root_host}:{root_port}')
+
+            # Request the full blockchain from the root node
+            response = requests.get(f'http://{root_host}:{root_port}/blockchain')
+            result_blockchain = Blockchain.from_json(response.json())
+
+            # Replace our local chain with the synchronized chain
+            self.blockchain.replace_chain(result_blockchain.chain)
+
+            print(f'\n -- Successfully synchronized! Chain length: {len(self.blockchain.chain)}')
+        except Exception as e:
+            print(f'\n -- Could not synchronize blockchain: {e}')
 
 class PubSub():
     """
@@ -61,7 +91,11 @@ def publish(self, channel, message):
         """
         Publish the message object to the channel.
         """
-        self.pubnub.publish().channel(channel).message(message).sync()
+        try:
+            result = self.pubnub.publish().channel(channel).message(message).sync()
+            print(f'\n-- Published to {channel}: {result.status.is_error()}')
+        except Exception as e:
+            print(f'\n-- Error publishing to {channel}: {e}')
 
     def broadcast_block(self, block):
         """

backend/wallet/transaction.py

@@ -69,19 +69,48 @@ def update(self, sender_wallet, recipient, amount):
 
         self.input = self.create_input(sender_wallet, self.output)
 
+    # TODO: consider making my own python library for this, to clean it up for the student.
+    # That, or clone from the course repo.
     def to_json(self):
         """
         Serialize the transaction.
+        Convert large signature integers to strings to prevent float conversion in JSON.
         """
-        return self.__dict__
+        transaction_dict = self.__dict__.copy()
+        
+        # If this transaction has a signature (not a mining reward), convert it to strings
+        if self.input != None and isinstance(self.input, dict) and 'signature' in self.input:
+            transaction_dict = {
+                'id': self.id,
+                'output': self.output.copy(),
+                'input': self.input.copy()
+            }
+            # Convert signature tuple/list to string representations
+            sig = self.input['signature']
+            transaction_dict['input']['signature'] = [str(sig[0]), str(sig[1])]
+        
+        return transaction_dict
 
     @staticmethod
     def from_json(transaction_json):
         """
         Deserialize a transaction's json representation back into a
-        Transaction instance
+        Transaction instance.
+        Convert signature strings back to integers.
         """
-        return Transaction(**transaction_json)
+        # Make a copy to avoid mutating the original
+        transaction_data = transaction_json.copy()
+        
+        # If there's a signature, convert strings back to integers
+        if 'input' in transaction_data and transaction_data['input'] is not None:
+            if isinstance(transaction_data['input'], dict) and 'signature' in transaction_data['input']:
+                sig = transaction_data['input']['signature']
+                # Convert string representations back to integers
+                if isinstance(sig[0], str):
+                    transaction_data['input'] = transaction_data['input'].copy()
+                    transaction_data['input']['signature'] = [int(sig[0]), int(sig[1])]
+        
+        return Transaction(**transaction_data)
 
     @staticmethod
     def is_valid_transaction(transaction):

frontend/src/config.js

@@ -1,4 +1,4 @@
-const API_BASE_URL = 'http://localhost:5050';
+const API_BASE_URL = process.env.REACT_APP_API_URL || 'http://localhost:5050';
 const NANOSECONDS_PY = 1;
 const MICROSECONDS_PY = 1000 * NANOSECONDS_PY;
 const MILLISECONDS_PY = 1000 * MICROSECONDS_PY;