3.1 Understanding Proof-of-Work

1. Introduce the concept of proof-of-work: Explain that proof-of-work requires miners to solve a computationally difficult puzzle to add a new block. This puzzle involves finding a hash value that meets certain criteria, such as having a specific number of leading zeros.

   Python
   pythonCopy code
   class Blockchain:
    def __init__(self):
        self.chain = []
        self.difficulty = 4  # Adjust the difficulty level as needed
   

   This code adds a difficulty attribute to the Blockchain class, which represents the number of leading zeros required in the hash.

2. Implement the proof_of_work method: This method will generate a valid hash by adjusting a nonce value until the hash meets the difficulty criteria.

   Python
   pythonCopy code
   import hashlib
   class Blockchain:
    def __init__(self):
        self.chain = []
        self.difficulty = 4def proof_of_work(self, block):
        target = "0" * self.difficulty
        nonce = 0while True:
            data = str(block) + str(nonce)
            hash_value = hashlib.sha256(data.encode()).hexdigest()
            if hash_value[:self.difficulty] == target:
                return hash_value
            nonce += 1
   

   This code adds the proof_of_work method to the Blockchain class. It uses a target string with the required number of leading zeros and adjusts the nonce value until a valid hash is found.

3.2 Adding Proof-of-Work to Block Creation

1. Update the add_block method: Modify the add_block method to include proof-of-work. Generate a valid hash for the new block using the proof_of_work method.

   Python
   pythonCopy code
   class Blockchain:
    def __init__(self):
        self.chain = []
        self.difficulty = 4def proof_of_work(self, block):
        # Implementation detailsdef add_block(self, block):
        previous_hash = self.chain[-1].hash() if len(self.chain) > 0 else None
        block.previous_hash = previous_hash
        block.mine(self.difficulty)
        self.chain.append(block)
   

   This code modifies the add_block method to set the previous_hash of the new block, call the mine method on the block with the difficulty level, and append the block to the chain.

2. Implement the mine method in the Block class: The mine method will adjust the block’s nonce value until a valid hash is found.

   Python
   pythonCopy code
   import hashlib
   class Block:
    def __init__(self, index, timestamp, data, previous_hash, nonce=0):
        self.index = index
        self.timestamp = timestamp
        self.data = data
        self.previous_hash = previous_hash
        self.nonce = nonce
        self.hash = self.calculate_hash()
   
    def calculate_hash(self):
        data = str(self.index) + str(self.timestamp) + str(self.data) + str(self.previous_hash) + str(self.nonce)
        return hashlib.sha256(data.encode()).hexdigest()
   
    def mine(self, difficulty):
        target = "0" * difficulty
        while self.hash[:difficulty] != target:
            self.nonce += 1
            self.hash = self.calculate_hash()
   

This code adds the mine method to the Block class. It adjusts the nonce value and recalculates the block’s hash until the hash meets the difficulty criteria.

3.3 Testing the Proof-of-Work Implementation

1. Create a new blockchain instance: Instantiate a new Blockchain object and add some blocks to the chain.

   Python
   pythonCopy code
   blockchain = Blockchain()
   block1 = Block(1, datetime.now(), "Block 1 Data")
   block2 = Block(2, datetime.now(), "Block 2 Data")
   block3 = Block(3, datetime.now(), "Block 3 Data")
   

   This code creates a new Blockchain object and three blocks.

2. Add the blocks to the blockchain: Use the add_block method to add the blocks to the chain.

   Python
   pythonCopy code
   blockchain.add_block(block1)
   blockchain.add_block(block2)
   blockchain.add_block(block3)
   

   This code adds the blocks to the blockchain.

3. Print the blockchain: Display the blockchain’s blocks and their hashes.

   Python
   pythonCopy code
   for block in blockchain.chain:
    print(f"Block: {block.index}")
    print(f"Hash: {block.hash}")
   

   This code iterates over the blockchain’s blocks and prints their index and hash values.

3.4 Conclusion

In this lesson, we have implemented the proof-of-work consensus algorithm in our blockchain. We introduced the concept of proof-of-work, explained how it requires miners to solve a computationally difficult puzzle, and implemented it in our blockchain by adjusting a nonce value until a valid hash is found. We also tested the proof-of-work implementation by adding blocks to the chain and displaying the blockchain’s contents.