feat: Exercise #8. Modules and HTTP

BREAKING CHANGE: Last exercise added

Author: NicolasOmar

8-modules-and-http/classes/block.py

@@ -0,0 +1,11 @@
+from time import time
+# CLASS IMPORTS
+from classes.printable import Printable
+
+class Block(Printable):
+  def __init__(self, index, previous_hash, transactions, proof, timestamp=None):
+    self.index = index
+    self.previous_hash = previous_hash
+    self.transactions = transactions
+    self.proof = proof
+    self.timestamp = time() if timestamp is None else timestamp

8-modules-and-http/classes/blockchain.py

@@ -0,0 +1,286 @@
+import functools
+import json
+import requests
+# CLASS IMPORTS
+from classes.block import Block
+from classes.transaction import Transaction
+from classes.verification import Verification
+# OTHER IMPORTS
+from utils import hash_block, add__line
+
+MINING_REWARD = 10
+
+class Blockchain:
+    def __init__(self, public_key, node_id):
+        genesis_block = Block(0, '', [], 100)
+        self.public_key = public_key
+        self.chain = [genesis_block]
+        self.open_transactions = []
+        # You create a set of nodes to include unique values (which will not be added
+        # if are repeated)
+        self.peer_nodes = set()
+        self.node_id = node_id
+        self.resolve_conflicts = False
+        self.load_data()
+    
+    @property
+    def chain(self):
+        return self.__chain[:]
+    
+    @property
+    def open_transactions(self):
+        return self.__open_transactions[:]
+    
+    @chain.setter
+    def chain(self, val):
+        self.__chain = val
+    
+    @open_transactions.setter
+    def open_transactions(self, val):
+        self.__open_transactions = val
+    
+    def save_data(self):
+        savable_chain = [block.__dict__ for block in [Block(block_el.index, block_el.previous_hash, [tx.__dict__ for tx in block_el.transactions], block_el.proof, block_el.timestamp) for block_el in self.__chain]]
+        savable_transactions = [tx.__dict__ for tx in self.__open_transactions]
+
+        with open(f'blockchain-{self.node_id}.txt', mode='w') as f:
+            f.write(json.dumps(savable_chain))
+            f.write('\n')
+            f.write(json.dumps(savable_transactions))
+            f.write('\n')
+            # Whey you create the file (or save it), you change the peer nodes to a list
+            # as another list of information to be saved
+            f.write(json.dumps(list(self.peer_nodes)))
+        
+    def load_data(self):
+        try:
+            with open(f'blockchain-{self.node_id}.txt', mode='r') as f:
+                file_content = f.readlines()
+                
+                loaded_blockchain = json.loads(file_content[0])
+                loaded_open_transactions = json.loads(file_content[1])
+                # When you load the file, its third line now will be all the loaded peer lines
+                loaded_peer_nodes = json.loads(file_content[2])
+                updated_blockchain = []
+                updated_transactions = []
+                
+                for current_block in loaded_blockchain:
+                    block_transactions = [Transaction(tx['sender'], tx['recipient'], tx['signature'], tx['amount']) for tx in current_block['transactions']]
+                    updated_block = Block(
+                        current_block['proof'],
+                        current_block['previous_hash'],
+                        block_transactions,
+                        current_block['proof'])
+                    updated_blockchain.append(updated_block)
+
+                for tx in loaded_open_transactions:
+                    updated_transaction = Transaction(tx['sender'], tx['recipient'], tx['signature'], tx['amount'])
+                    updated_transactions.append(updated_transaction)
+                    
+                self.chain = updated_blockchain
+                self.open_transactions = updated_transactions
+                # After loading them, you adjust them again as a set of values instead a list
+                self.peer_nodes = set(loaded_peer_nodes)
+        except (IOError, IndexError):
+            # Exception logic has been handled in class initializer
+            pass
+        finally:
+            print('Cleanup')
+
+    def get_balance(self, sender=None):
+        if sender == None:
+            if self.public_key == None:
+                return None
+            participant = self.public_key
+        else:
+            participant = sender
+        
+        participant = self.public_key
+        tx_sender = [[tx.amount for tx in block.transactions
+                      if tx.sender == participant] for block in self.__chain]
+        open_tx_sender = [tx.amount
+                          for tx in self.__open_transactions if tx.sender == participant]
+        tx_sender.append(open_tx_sender)
+        print(tx_sender)
+        amount_sent = functools.reduce(lambda tx_sum, tx_amt: tx_sum + sum(tx_amt)
+                             if len(tx_amt) > 0 else tx_sum + 0, tx_sender, 0)
+        tx_recipient = [[tx.amount for tx in block.transactions
+                         if tx.recipient == participant] for block in self.__chain]
+        amount_received = functools.reduce(lambda tx_sum, tx_amt: tx_sum + sum(tx_amt)
+                                 if len(tx_amt) > 0 else tx_sum + 0, tx_recipient, 0)
+        return amount_received - amount_sent
+
+    def take_last_blockchain_value(self):
+        if len(self.__chain) < 1:
+            return None
+        
+        return self.__chain[-1]
+    
+    def add_transaction(self, recipient, sender, signature, amount=1.0, is_receiving=False):
+        """
+            Add a new transaction to the list of open transactions (which will be added to the next mined block)
+
+            Arguments:
+                :sender: The sender of the coins.
+                :recipient: The recipient of the coins.
+                :amount: The amount of the transaction.
+        """
+        new_transaction = Transaction(sender, recipient, signature, amount)
+
+        if Verification.verify_transaction(new_transaction, self.get_balance):
+            self.__open_transactions.append(new_transaction)
+            self.save_data()
+
+            if not is_receiving:
+                for peer_node_url in self.peer_nodes:
+                    broadcast_url = f'http://{peer_node_url}/broadcast-transaction'
+                    transaction_payload = { 'sender': sender, 'recipient': recipient, 'signature': signature, 'amount': amount }
+                    
+                    try:
+                        internal_response = requests.post(broadcast_url, json=transaction_payload)
+
+                        if internal_response.status_code == 400 or internal_response.status_code == 500:
+                            print('Transaction declined, needs resolving')
+                            return False
+                    except requests.exceptions.ConnectionError:
+                        continue
+            return True
+        else:
+            return False
+        
+    def get_open_transactions(self):
+        return self.__open_transactions[:]
+
+    def mine_block(self):
+        if self.public_key == None:
+            return None
+        
+        last_block = self.__chain[-1]
+        hashed_block = hash_block(last_block)
+        proof_of_work_value = self.proof_of_work()
+        
+        reward_transaction = Transaction('MINING', self.public_key, '', MINING_REWARD)
+
+        transactions = self.__open_transactions.copy()
+        transactions.append(reward_transaction)
+        new_block = Block(
+            len(self.__chain),
+            hashed_block,
+            transactions,
+            proof_of_work_value
+        )
+        self.__chain.append(new_block)
+        self.__open_transactions = []
+        self.save_data()
+
+        for node_url in self.peer_nodes:
+            try:
+                broadcast_url = f'http://{node_url}/broadcast-block'
+                block_dict = new_block.__dict__.copy()
+                block_dict['transactions'] = [tx.__dict__ for tx in block_dict['transactions']]
+
+                internal_response = requests.post(broadcast_url, json={ 'block': block_dict })
+
+                if internal_response.status_code == 400 or internal_response.status_code == 500:
+                    print('Block declined, needs resolving')
+                if internal_response.status_code == 409:
+                    self.resolve_conflicts = True
+            except requests.exceptions.ConnectionError:
+                continue
+
+        return new_block
+    
+    def add_block(self, new_block):
+        transaction_list = [Transaction(
+            tx['sender'],
+            tx['recipient'],
+            tx['signature'],
+            tx['amount']
+        ) for tx in new_block['transactions']]
+        proof_is_valid = Verification.valid_proof(transaction_list[-1], new_block['previous_hash'], new_block['proof'])
+        hashes_match = hash_block(self.chain[-1]) == new_block['previous_hash']
+
+        if not proof_is_valid or not hashes_match:
+            return False
+        
+        converted_block = Block(
+            new_block['index'],
+            new_block['previous_hash'],
+            transaction_list,
+            new_block['proof'],
+            new_block['timestamp'])
+        
+        self.__chain.append(converted_block)
+        stored_transactions = self.__open_transactions[:]
+
+        for incoming_tx in new_block['transactions']:
+            for open_tx in stored_transactions:
+                if open_tx.sender ==  incoming_tx['sender'] and open_tx.recipient ==  incoming_tx['recipient'] and open_tx.signature ==  incoming_tx['signature']:
+                    try:
+                        self.__open_transactions.remove(open_tx)
+                    except:
+                        print('Item was already removed')
+
+        self.save_data()
+
+        return True
+    
+    def proof_of_work(self):
+        last_block = self.__chain[-1]
+        hash_last_block = hash_block(last_block)
+        proof = 0
+        while not Verification.valid_proof(self.__open_transactions, hash_last_block, proof):
+            proof += 1
+        return proof
+    
+    def resolve(self):
+        winner_chain = self.chain
+        chain_has_been_replaced = False
+
+        for node in self.peer_nodes:
+            url = f'http://{node}/chain'
+            try:
+                chain_response = requests.post(url)
+                node_chain = chain_response.json()
+                node_chain = [Block(
+                    block['index'],
+                    block['previous_hash'],
+                    [Transaction(
+                        block_tx['sender'],
+                        block_tx['recipient'],
+                        block_tx['signature'],
+                        block_tx['amount']
+                    ) for block_tx in block['transactions']],
+                    block['proof'],
+                    block['timestamp'],
+                ) for block in node_chain]
+
+                node_chain_length = len(node_chain)
+                local_chain_length = len(winner_chain)
+
+                if node_chain_length > local_chain_length and Verification.verify_chain(node_chain):
+                    winner_chain = node_chain
+                    chain_has_been_replaced = True
+            except requests.exceptions.ConnectionError:
+                continue
+        
+        self.resolve_conflicts = False
+        self.chain = winner_chain
+
+        if chain_has_been_replaced:
+            self.open_transactions = []
+
+        self.save_data()
+        
+        return chain_has_been_replaced
+
+    def add_peer_node(self, node):
+        self.peer_nodes.add(node)
+        self.save_data()
+
+    def remove_peer_node(self, node):
+        self.peer_nodes.discard(node)
+        self.save_data()
+
+    def get_all_nodes(self):
+        return list(self.peer_nodes)

8-modules-and-http/classes/printable.py

@@ -0,0 +1,3 @@
+class Printable:
+  def __repr__(self):
+    return str(self.__dict__)

8-modules-and-http/classes/transaction.py

@@ -0,0 +1,16 @@
+from collections import OrderedDict
+# CLASS IMPORTS
+from classes.printable import Printable
+
+class Transaction(Printable):
+  def __init__(self, sender, recipient, signature, amount):
+      self.sender = sender
+      self.recipient = recipient
+      self.amount = amount
+      self.signature = signature
+
+  def to_ordered_dict(self):
+    return OrderedDict([
+      ('sender', self.sender),
+      ('recipient', self.recipient),
+      ('amount', self.amount)])

8-modules-and-http/classes/verification.py

@@ -0,0 +1,37 @@
+# OTHER IMPORTS
+from utils import hash_block, hash_string_256
+from classes.wallet import Wallet
+
+class Verification:
+  @classmethod
+  def verify_chain(cls, blockchain):
+    """ The function helps to verify the integrity of the blockchain by checking if each block's previous hash matches the hash of the previous block. """
+    for (index, block) in enumerate(blockchain):
+        if index == 0:
+            continue
+        if block.previous_hash != hash_block(blockchain[index - 1]):
+            return False
+        if not cls.valid_proof(block.transactions[:-1], block.previous_hash, block.proof):
+            print('Proof of work is invalid')
+            return False
+    return True
+  
+  @staticmethod
+  def verify_transaction(transaction, get_balance, check_funds=True):
+    if check_funds:
+      sender_balance = get_balance(transaction.sender)
+      return sender_balance >= transaction.amount and Wallet.verify_transaction(transaction)
+    else:
+      Wallet.verify_transaction(transaction)
+  
+  @classmethod
+  def verify_transactions(self, open_transactions):
+    """ The function verifies all open transactions to ensure they are valid. """
+    return all([tx for tx in open_transactions if not self.verify_transaction(tx)])
+  
+  @staticmethod
+  def valid_proof(transactions, last_hash, proof):
+    guess = (str([tx.to_ordered_dict() for tx in transactions]) + str(last_hash) + str(proof)).encode()
+    guess_hash = hash_string_256(guess)
+    
+    return guess_hash[0:2] == '00'