How to Create a Blockchain in Python

Blockchain technology has taken the world by storm, revolutionizing industries ranging from finance to supply chain management. It promises a secure, transparent, and decentralized way of recording transactions. Although originally popularized by Bitcoin, the blockchain concept has expanded to various applications beyond cryptocurrencies. In this article, we will explore how to create a simple blockchain in Python. We'll break down the process into digestible steps, ensuring even those with a basic understanding of Python can follow along.

What is a Blockchain?

At its core, a blockchain is a digital ledger of transactions that is duplicated and distributed across a network of computers. Each block in the chain contains a number of transactions, and every time a new transaction occurs on the blockchain, a record of that transaction is added to every participant’s ledger. The decentralized database managed by multiple participants is known as Distributed Ledger Technology (DLT).

Blockchain is designed to be secure and resistant to modification. Once recorded, the data in any given block cannot be altered retroactively without altering all subsequent blocks, which requires network consensus. This feature makes blockchain particularly appealing for industries requiring high levels of data integrity and security.

Components of a Blockchain

Before diving into the code, it’s essential to understand the fundamental components of a blockchain:

1. Block: The fundamental unit of a blockchain. It contains data, a timestamp, and a cryptographic hash of the previous block.
2. Chain: A sequence of blocks, each referencing its predecessor.
3. Node: A participant in the blockchain network. Every node has a copy of the entire blockchain.
4. Transaction: The data that is recorded in the blockchain.
5. Hash: A unique identifier generated from data within the block. It serves as the digital fingerprint of that block.

Why Use Python for Blockchain?

Python is a versatile programming language, known for its simplicity and readability, making it an excellent choice for beginners and seasoned developers alike. With a rich ecosystem of libraries, Python allows developers to implement complex functionalities with minimal effort. For blockchain development, Python's libraries such as hashlib and json are extremely useful for cryptographic operations and data management.

Step-by-Step Guide to Creating a Blockchain in Python

Let’s start building a simple blockchain using Python. We’ll create a class-based implementation for clarity and structure.

Step 1: Setting Up the Environment

First, ensure you have Python installed on your system. You can check this by running the following command in your terminal:

bash
python --version

If Python is not installed, you can download it from the official Python website.

Step 2: Importing Required Libraries

We will use the hashlib library to generate hashes and the json library to handle the data. Open your Python editor and start by importing these libraries:

python
import hashlib
import json
from time import time

Step 3: Creating the Blockchain Class

We'll start by defining a Blockchain class that will have methods to manage the blockchain. This class will initialize a list to store our blockchain and another to store the current transactions.

python
class Blockchain:
    def __init__(self):
        self.chain = []
        self.current_transactions = []

        # Create the genesis block
        self.new_block(previous_hash='1', proof=100)

Step 4: Creating a New Block

Every block will have an index, a timestamp, a list of transactions, a proof (which we’ll discuss later), and the hash of the previous block. Let’s define the method to create a new block:

python
    def new_block(self, proof, previous_hash=None):
        block = {
            'index': len(self.chain) + 1,
            'timestamp': time(),
            'transactions': self.current_transactions,
            'proof': proof,
            'previous_hash': previous_hash or self.hash(self.chain[-1]),
        }

        # Reset the current list of transactions
        self.current_transactions = []

        self.chain.append(block)
        return block

Step 5: Adding Transactions

We need a method to create new transactions. Each transaction will contain a sender, a recipient, and an amount. We'll store these transactions in a list, which will be added to a block later.

python
    def new_transaction(self, sender, recipient, amount):
        self.current_transactions.append({
            'sender': sender,
            'recipient': recipient,
            'amount': amount,
        })

        return self.last_block['index'] + 1

Step 6: Hashing a Block

A hash function is crucial to the security of the blockchain. It creates a unique digital fingerprint of the data in the block. Here’s how we’ll implement it using SHA-256:

python
    @staticmethod
    def hash(block):
        # We must make sure that the Dictionary is Ordered, or we’ll have inconsistent hashes
        block_string = json.dumps(block, sort_keys=True).encode()
        return hashlib.sha256(block_string).hexdigest()

Step 7: Proof of Work

Proof of Work (PoW) is a consensus algorithm used to confirm transactions and produce new blocks in the chain. It’s the core of the Bitcoin protocol. Our proof_of_work method will simply find a number that, when hashed, produces a hash with a specific number of leading zeros.

python
    def proof_of_work(self, last_proof):
        proof = 0
        while self.valid_proof(last_proof, proof) is False:
            proof += 1
        return proof

    @staticmethod
    def valid_proof(last_proof, proof):
        guess = f'{last_proof}{proof}'.encode()
        guess_hash = hashlib.sha256(guess).hexdigest()
        return guess_hash[:4] == "0000"

Step 8: Adding a New Block After Proof of Work

When a new transaction is made, and a proof of work is found, a new block will be created. Here’s how it all comes together:

python
# Create an instance of the Blockchain
blockchain = Blockchain()

# Add a new transaction
blockchain.new_transaction(sender="Alice", recipient="Bob", amount=50)

# Perform Proof of Work
last_proof = blockchain.last_block['proof']
proof = blockchain.proof_of_work(last_proof)

# Add the new block to the blockchain
previous_hash = blockchain.hash(blockchain.last_block)
block = blockchain.new_block(proof, previous_hash)

Step 9: Full Blockchain Code

Here is the full code for a simple blockchain:

python
import hashlib
import json
from time import time

class Blockchain:
    def __init__(self):
        self.chain = []
        self.current_transactions = []

        # Create the genesis block
        self.new_block(previous_hash='1', proof=100)

    def new_block(self, proof, previous_hash=None):
        block = {
            'index': len(self.chain) + 1,
            'timestamp': time(),
            'transactions': self.current_transactions,
            'proof': proof,
            'previous_hash': previous_hash or self.hash(self.chain[-1]),
        }

        self.current_transactions = []
        self.chain.append(block)
        return block

    def new_transaction(self, sender, recipient, amount):
        self.current_transactions.append({
            'sender': sender,
            'recipient': recipient,
            'amount': amount,
        })
        return self.last_block['index'] + 1

    @staticmethod
    def hash(block):
        block_string = json.dumps(block, sort_keys=True).encode()
        return hashlib.sha256(block_string).hexdigest()

    @property
    def last_block(self):
        return self.chain[-1]

    def proof_of_work(self, last_proof):
        proof = 0
        while self.valid_proof(last_proof, proof) is False:
            proof += 1
        return proof

    @staticmethod
    def valid_proof(last_proof, proof):
        guess = f'{last_proof}{proof}'.encode()
        guess_hash = hashlib.sha256(guess).hexdigest()
        return guess_hash[:4] == "0000"

# Test the blockchain
blockchain = Blockchain()
print("Genesis Block:", blockchain.chain)

# Add a new transaction
blockchain.new_transaction(sender="Alice", recipient="Bob", amount=50)

# Perform Proof of Work
last_proof = blockchain.last_block['proof']
proof = blockchain.proof_of_work(last_proof)

# Add the new block to the blockchain
previous_hash = blockchain.hash(blockchain.last_block)
block = blockchain.new_block(proof, previous_hash)

print("Blockchain after adding a new block:")
print(blockchain.chain)

Conclusion

In this tutorial, we've built a basic blockchain using Python. This implementation covers the essentials of what a blockchain is: creating a chain, adding transactions, ensuring data integrity through hashing, and achieving consensus using a proof of work algorithm. Although this example is simplified, it provides a solid foundation for understanding how blockchains function and can be a stepping stone to more complex applications, such as developing a cryptocurrency or a distributed ledger for secure data management. As you continue to explore and experiment, you can add features like networking, validation, and smart contracts to create more sophisticated blockchain systems.

Happy Coding!