Complete section: Connect the Blockchain and Cryptocurrency

Author: 15Dkatz

backend/app/__init__.py

@@ -12,7 +12,7 @@
 
 app = Flask(__name__)
 blockchain = Blockchain()
-wallet = Wallet()
+wallet = Wallet(blockchain)
 transaction_pool = TransactionPool()
 pubsub = PubSub(blockchain, transaction_pool)
 
@@ -26,7 +26,9 @@ def route_blockchain():
 
 @app.route('/blockchain/mine')
 def route_blockchain_mine():
-    blockchain.add_block(transaction_pool.transaction_data())
+    transaction_data = transaction_pool.transaction_data()
+    transaction_data.append(Transaction.reward_transaction(wallet).to_json())
+    blockchain.add_block(transaction_data)
     block = blockchain.chain[-1]
     pubsub.broadcast_block(block)
     transaction_pool.clear_blockchain_transactions(blockchain)
@@ -55,6 +57,10 @@ def route_wallet_transact():
 
     return jsonify(transaction.to_json())
 
+@app.route('/wallet/info')
+def route_wallet_info():
+    return jsonify({ 'address': wallet.address, 'balance': wallet.balance })
+
 ROOT_PORT = 5000
 PORT = ROOT_PORT
 

backend/blockchain/blockchain.py

@@ -1,4 +1,7 @@
 from backend.blockchain.block import Block
+from backend.wallet.transaction import Transaction
+from backend.wallet.wallet import Wallet
+from backend.config import MINING_REWARD_INPUT
 
 class Blockchain:
     """
@@ -65,6 +68,53 @@ def is_valid_chain(chain):
             last_block = chain[i-1]
             Block.is_valid_block(last_block, block)
 
+        Blockchain.is_valid_transaction_chain(chain)
+
+    @staticmethod
+    def is_valid_transaction_chain(chain):
+        """
+        Enforce the rules of a chain composed of blocks of transactions.
+            - Each transaction must only appear once in the chain.
+            - There can only be one mining reward per block.
+            - Each transaction must be valid.
+        """
+        transaction_ids = set()
+
+        for i in range(len(chain)):
+            block = chain[i]
+            has_mining_reward = False
+
+            for transaction_json in block.data:
+                transaction = Transaction.from_json(transaction_json)
+
+                if transaction.id in transaction_ids:
+                    raise Exception(f'Transaction {transaction.id} is not unique')
+
+                transaction_ids.add(transaction.id)
+
+                if transaction.input == MINING_REWARD_INPUT:
+                    if has_mining_reward:
+                        raise Exception(
+                            'There can only be one mining reward per block. '\
+                            f'Check block with hash: {block.hash}'
+                        )
+
+                    has_mining_reward = True
+                else:
+                    historic_blockchain = Blockchain()
+                    historic_blockchain.chain = chain[0:i]
+                    historic_balance = Wallet.calculate_balance(
+                        historic_blockchain,
+                        transaction.input['address']
+                    )
+
+                    if historic_balance != transaction.input['amount']:
+                        raise Exception(
+                            f'Transaction {transaction.id} has an invalid '\
+                            'input amount'
+                        )
+
+                Transaction.is_valid_transaction(transaction)
 
 def main():
     blockchain = Blockchain()

backend/config.py

@@ -5,4 +5,7 @@
 
 MINE_RATE = 4 * SECONDS
 
-STARTING_BALANCE = 1000
+STARTING_BALANCE = 1000
+
+MINING_REWARD = 50
+MINING_REWARD_INPUT = { 'address': '*--official-mining-reward--*' }

backend/scripts/test_app.py

@@ -17,6 +17,9 @@ def post_wallet_transact(recipient, amount):
         json={ 'recipient': recipient, 'amount': amount }
     ).json()
 
+def get_wallet_info():
+    return requests.get(f'{BASE_URL}/wallet/info').json()
+
 start_blockchain = get_blockchain()
 print(f'start_blockchain: {start_blockchain}')
 
@@ -30,4 +33,7 @@ def post_wallet_transact(recipient, amount):
 
 time.sleep(1)
 mined_block = get_blockchain_mine()
-print(f'\nmined_block: {mined_block}')
+print(f'\nmined_block: {mined_block}')
+
+wallet_info = get_wallet_info()
+print(f'\nwallet_info: {wallet_info}')

backend/tests/blockchain/test_blockchain.py

@@ -2,6 +2,8 @@
 
 from backend.blockchain.blockchain import Blockchain
 from backend.blockchain.block import GENESIS_DATA
+from backend.wallet.wallet import Wallet
+from backend.wallet.transaction import Transaction
 
 def test_blockchain_instance():
     blockchain = Blockchain()
@@ -18,7 +20,7 @@ def test_add_block():
 def blockchain_three_blocks():
     blockchain = Blockchain()
     for i in range(3):
-        blockchain.add_block(i)
+        blockchain.add_block([Transaction(Wallet(), 'recipient', i).to_json()])
     return blockchain
 
 def test_is_valid_chain(blockchain_three_blocks):
@@ -47,4 +49,42 @@ def test_replace_chain_bad_chain(blockchain_three_blocks):
     blockchain_three_blocks.chain[1].hash = 'evil_hash'
 
     with pytest.raises(Exception, match='The incoming chain is invalid'):
-        blockchain.replace_chain(blockchain_three_blocks.chain)
+        blockchain.replace_chain(blockchain_three_blocks.chain)
+
+def test_valid_transaction_chain(blockchain_three_blocks):
+    Blockchain.is_valid_transaction_chain(blockchain_three_blocks.chain)
+
+def test_is_valid_transaction_chain_duplicate_transactions(blockchain_three_blocks):
+    transaction = Transaction(Wallet(), 'recipient', 1).to_json()
+    blockchain_three_blocks.add_block([transaction, transaction])
+
+    with pytest.raises(Exception, match='is not unique'):
+        Blockchain.is_valid_transaction_chain(blockchain_three_blocks.chain)
+
+def test_is_valid_transaction_chain_multiple_rewards(blockchain_three_blocks):
+    reward_1 = Transaction.reward_transaction(Wallet()).to_json()
+    reward_2 = Transaction.reward_transaction(Wallet()).to_json()
+    blockchain_three_blocks.add_block([reward_1, reward_2])
+
+    with pytest.raises(Exception, match='one mining reward per block'):
+        Blockchain.is_valid_transaction_chain(blockchain_three_blocks.chain)
+
+def test_is_valid_transaction_chain_bad_transaction(blockchain_three_blocks):
+    bad_transaction = Transaction(Wallet(), 'recipient', 1)
+    bad_transaction.input['signature'] = Wallet().sign(bad_transaction.output)
+    blockchain_three_blocks.add_block([bad_transaction.to_json()])
+
+    with pytest.raises(Exception):
+        Blockchain.is_valid_transaction_chain(blockchain_three_blocks.chain)
+
+def test_is_valid_transaction_chain_bad_historic_balance(blockchain_three_blocks):
+    wallet = Wallet()
+    bad_transaction = Transaction(wallet, 'recipient', 1)
+    bad_transaction.output[wallet.address] = 9000
+    bad_transaction.input['amount'] = 9001
+    bad_transaction.input['signature'] = wallet.sign(bad_transaction.output)
+
+    blockchain_three_blocks.add_block([bad_transaction.to_json()])
+
+    with pytest.raises(Exception, match='has an invalid input amount'):
+        Blockchain.is_valid_transaction_chain(blockchain_three_blocks.chain)

backend/tests/wallet/test_transaction.py

@@ -2,6 +2,7 @@
 
 from backend.wallet.transaction import Transaction
 from backend.wallet.wallet import Wallet
+from backend.config import MINING_REWARD, MINING_REWARD_INPUT
 
 def test_transaction():
     sender_wallet = Wallet()
@@ -82,3 +83,29 @@ def test_valid_transaction_with_invalid_signature():
 
     with pytest.raises(Exception, match='Invalid signature'):
         Transaction.is_valid_transaction(transaction)
+
+def test_reward_transaction():
+    miner_wallet = Wallet()
+    transaction = Transaction.reward_transaction(miner_wallet)
+
+    assert transaction.input == MINING_REWARD_INPUT
+    assert transaction.output[miner_wallet.address] == MINING_REWARD
+
+def test_valid_reward_transaction():
+    reward_transaction = Transaction.reward_transaction(Wallet())
+    Transaction.is_valid_transaction(reward_transaction)
+
+def test_invalid_reward_transaction_extra_recipient():
+    reward_transaction = Transaction.reward_transaction(Wallet())
+    reward_transaction.output['extra_recipient'] = 60
+
+    with pytest.raises(Exception, match='Invalid mining reward'):
+        Transaction.is_valid_transaction(reward_transaction)
+
+def test_invalid_reward_transaction_invalid_amount():
+    miner_wallet = Wallet()
+    reward_transaction = Transaction.reward_transaction(miner_wallet)
+    reward_transaction.output[miner_wallet.address] = 9001
+
+    with pytest.raises(Exception, match='Invalid mining reward'):
+        Transaction.is_valid_transaction(reward_transaction)

backend/tests/wallet/test_wallet.py

@@ -1,4 +1,7 @@
 from backend.wallet.wallet import Wallet
+from backend.wallet.transaction import Transaction
+from backend.blockchain.blockchain import Blockchain
+from backend.config import STARTING_BALANCE
 
 def test_verify_valid_signature():
     data = { 'foo': 'test_data' }
@@ -12,4 +15,38 @@ def test_verify_invalid_signature():
     wallet = Wallet()
     signature = wallet.sign(data)
 
-    assert not Wallet.verify(Wallet().public_key, data, signature)
+    assert not Wallet.verify(Wallet().public_key, data, signature)
+
+def test_calcalate_balance():
+    blockchain = Blockchain()
+    wallet = Wallet()
+
+    assert Wallet.calculate_balance(blockchain, wallet.address) == STARTING_BALANCE
+
+    amount = 50
+    transaction = Transaction(wallet, 'recipient', amount)
+    blockchain.add_block([transaction.to_json()])
+
+    assert Wallet.calculate_balance(blockchain, wallet.address) == \
+        STARTING_BALANCE - amount
+
+    received_amount_1 = 25
+    received_transaction_1 = Transaction(
+        Wallet(),
+        wallet.address,
+        received_amount_1
+    )
+
+    received_amount_2 = 43
+    received_transaction_2 = Transaction(
+        Wallet(),
+        wallet.address,
+        received_amount_2
+    )
+
+    blockchain.add_block(
+        [received_transaction_1.to_json(), received_transaction_2.to_json()]
+    )
+
+    assert Wallet.calculate_balance(blockchain, wallet.address) == \
+        STARTING_BALANCE - amount + received_amount_1 + received_amount_2

backend/wallet/transaction.py

@@ -2,6 +2,7 @@
 import uuid
 
 from backend.wallet.wallet import Wallet
+from backend.config import MINING_REWARD, MINING_REWARD_INPUT
 
 class Transaction:
     """
@@ -88,6 +89,11 @@ def is_valid_transaction(transaction):
         Validate a transaction.
         Raise an exception for invalid transactions.
         """
+        if transaction.input == MINING_REWARD_INPUT:
+            if list(transaction.output.values()) != [MINING_REWARD]:
+                raise Exception('Invalid mining reward')
+            return
+
         output_total = sum(transaction.output.values())
 
         if transaction.input['amount'] != output_total:
@@ -100,6 +106,16 @@ def is_valid_transaction(transaction):
         ):
             raise Exception('Invalid signature')
 
+    @staticmethod
+    def reward_transaction(miner_wallet):
+        """
+        Generate a reward transaction that award the miner.
+        """
+        output = {}
+        output[miner_wallet.address] = MINING_REWARD
+
+        return Transaction(input=MINING_REWARD_INPUT, output=output)
+
 def main():
     transaction = Transaction(Wallet(), 'recipient', 15)
     print(f'transaction.__dict__: {transaction.__dict__}')

backend/wallet/wallet.py

@@ -17,16 +17,20 @@ class Wallet:
     Keeps track of the miner's balance.
     Allows a miner to authorize transactions.
     """
-    def __init__(self):
+    def __init__(self, blockchain=None):
+        self.blockchain = blockchain
         self.address = str(uuid.uuid4())[0:8]
-        self.balance = STARTING_BALANCE
         self.private_key = ec.generate_private_key(
             ec.SECP256K1(),
             default_backend()
         )
         self.public_key = self.private_key.public_key()
         self.serialize_public_key()
 
+    @property
+    def balance(self):
+        return Wallet.calculate_balance(self.blockchain, self.address)
+
     def sign(self, data):
         """
         Generate a signature based on the data using the local private key.
@@ -67,6 +71,31 @@ def verify(public_key, data, signature):
         except InvalidSignature:
             return False
 
+    @staticmethod
+    def calculate_balance(blockchain, address):
+        """
+        Calculate the balance of the given address considering the transaction
+        data within the blockchain.
+
+        The balance is found by adding the output values that belong to the
+        address since the most recent transaction by that address.
+        """
+        balance = STARTING_BALANCE
+
+        if not blockchain:
+            return balance
+
+        for block in blockchain.chain:
+            for transaction in block.data:
+                if transaction['input']['address'] == address:
+                    # Any time the address conducts a new transaction it resets
+                    # its balance
+                    balance = transaction['output'][address]
+                elif address in transaction['output']:
+                    balance += transaction['output'][address]
+
+        return balance
+
 def main():
     wallet = Wallet()
     print(f'wallet.__dict__: {wallet.__dict__}')