Build a Simple Blockchain in Python from Scratch

Blockchain technology has revolutionized how we think about data security and decentralization. At its core, a blockchain is a distributed, immutable digital ledger that records transactions in a secure and transparent way. While often associated with cryptocurrencies, its applications extend far beyond.

This guide will walk you through creating a basic blockchain using Python. You'll learn the fundamental concepts, including blocks, hashing, and proof-of-work, by building a functional prototype.

Core Components of a Blockchain

A blockchain is essentially a chain of digital blocks. Each block contains three crucial pieces of information:

Data: This can be any information, such as transaction details.
Its own hash: A unique digital fingerprint, created using a cryptographic hash function like SHA-256.
The previous block's hash: This links the blocks together, creating the "chain."

This structure makes a blockchain tamper-evident. If someone alters the data in a block, its hash changes immediately. This, in turn, breaks the chain because the following block will still contain the old, incorrect hash of the previous block.

Building Your Python Blockchain

We'll use Python due to its simplicity and powerful libraries. Our project will involve creating a Blockchain class that can add new blocks, validate the chain's integrity, and display the entire ledger.

Step 1: Import Required Libraries

We need a few standard Python libraries to get started.

import hashlib
import json
import time
from datetime import datetime

hashlib provides the SHA-256 hashing algorithm for creating digital fingerprints.
json helps us format and structure the data within each block.
datetime and time are used to timestamp each block.

Step 2: Create the Blockchain Class

We begin by defining a Blockchain class. Its constructor initializes an empty list to hold our chain and creates the genesis block—the very first block in the chain.

class Blockchain:
    def __init__(self):
        self.chain = []
        self.create_block(proof=1, previous_hash='0')

Step 3: The `create_block` Method

This method is responsible for forging a new block and adding it to the chain.

    def create_block(self, proof, previous_hash):
        block = {
            'index': len(self.chain) + 1,
            'timestamp': str(datetime.now()),
            'proof': proof,
            'previous_hash': previous_hash,
        }
        self.chain.append(block)
        return block

Index: The block's position in the chain.
Timestamp: The exact time the block was created.
Proof: The number found during the mining process (Proof-of-Work).
Previous Hash: The hash of the preceding block, which ensures continuity.

Step 4: Hashing a Block

We need a function to calculate the cryptographic hash of a block. We'll use the SHA-256 algorithm.

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

This function takes a block, converts it to a JSON string, encodes it, and then returns its SHA-256 hash.

Step 5: Implementing Proof-of-Work

Proof-of-Work (PoW) is a consensus algorithm that makes mining new blocks computationally difficult, preventing spam and network abuse. Miners compete to solve a mathematical puzzle.

    def proof_of_work(self, previous_proof):
        new_proof = 1
        check_proof = False
        
        while not check_proof:
            # The problem is designed to be asymmetric: hard to solve, easy to verify.
            hash_operation = hashlib.sha256(
                str(new_proof**2 - previous_proof**2).encode()).hexdigest()
            # Check if the first 4 characters of the hash are '0000'
            if hash_operation[:4] == '0000':
                check_proof = True
            else:
                new_proof += 1
                
        return new_proof

In this simplified example, miners must find a number new_proof such that the hash of (new_proof^2 - previous_proof^2) starts with four leading zeros.

Step 6: Validating the Chain

A critical function of any blockchain node is to validate the entire chain to ensure no one has tampered with any blocks.

    def is_chain_valid(self, chain):
        previous_block = chain[0]  # Genesis block
        block_index = 1
        
        while block_index < len(chain):
            block = chain[block_index]
            # Check 1: Does the block's 'previous_hash' correctly point to the previous block's hash?
            if block['previous_hash'] != self.hash(previous_block):
                return False
            
            # Check 2: Is the Proof-of-Work for the current block valid?
            previous_proof = previous_block['proof']
            proof = block['proof']
            hash_operation = hashlib.sha256(
                str(proof**2 - previous_proof**2).encode()).hexdigest()
            
            if hash_operation[:4] != '0000':
                return False
            
            previous_block = block
            block_index += 1
            
        return True

This validator runs two checks on every block:

It verifies that the previous_hash field correctly matches the hash of the preceding block.
It re-calculates the hash operation to confirm the Proof-of-Work is valid.

Creating a Web Interface with Flask

To interact with our blockchain, we can wrap it in a simple web API using the Flask framework. This will allow us to mine new blocks and view the chain through HTTP requests.

👉 Explore more advanced blockchain development tools

Setting Up Flask Endpoints

from flask import Flask, jsonify

app = Flask(__name__)
blockchain = Blockchain()

@app.route('/mine_block', methods=['GET'])
def mine_block():
    # Mining logic goes here
    return jsonify(response), 200

@app.route('/get_chain', methods=['GET'])
def get_chain():
    response = {
        'chain': blockchain.chain,
        'length': len(blockchain.chain)
    }
    return jsonify(response), 200

@app.route('/is_valid', methods=['GET'])
def is_valid():
    is_valid = blockchain.is_chain_valid(blockchain.chain)
    response = { 'message': 'The Blockchain is valid.' } if is_valid else { 'message': 'The Blockchain is NOT valid.' }
    return jsonify(response), 200

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

/mine_block: This endpoint triggers the mining of a new block.
/get_chain: This returns the entire blockchain and its current length.
/is_valid: This endpoint runs the validation function and returns the result.

Expected Outputs

When you run the Flask app and access these endpoints, you'll see outputs like this:

Mining a block (/mine_block):

{
  "index": 2,
  "message": "A block is MINED",
  "previous_hash": "734dd03fe5...",
  "proof": 632238,
  "timestamp": "2024-11-27 22:47:59.309000"
}

Viewing the full chain (/get_chain):

{
  "chain": [
    {
      "index": 1,
      "previous_hash": "0",
      "proof": 1,
      "timestamp": "2024-11-27 22:47:05.915000"
    },
    {
      "index": 2,
      "previous_hash": "734dd03fe5...",
      "proof": 632238,
      "timestamp": "2024-11-27 22:47:59.309000"
    }
  ],
  "length": 2
}

Validating the chain (/is_valid):

{
  "message": "The Blockchain is valid."
}

Frequently Asked Questions

What is the main purpose of hashing in a blockchain?
Hashing creates a unique, fixed-size digital fingerprint for each block's data. Any change in the data completely alters the hash, making tampering immediately obvious. It is the primary mechanism ensuring the blockchain's immutability and security.

Why is Proof-of-Work necessary?
Proof-of-Work serves two key purposes. First, it makes mining new blocks computationally expensive, which prevents malicious actors from easily spamming the network or altering the chain. Second, it provides a decentralized consensus mechanism, allowing all nodes in the network to agree on the valid state of the blockchain.

Can I store any type of data in a block?
Yes, the data field in a block is flexible. In cryptocurrency applications, it typically stores transaction details. However, you can store other types of information, such as contracts, records, or identifiers, making the technology useful for supply chain management, voting systems, and digital notarization.

Is this Python blockchain secure for real applications?
No, this is a simplified educational model. While it demonstrates core principles, a production-grade blockchain requires a peer-to-peer network, a more robust consensus algorithm, and enhanced security measures to handle real-world threats and scalability demands.

How does the 'previous_hash' create immutability?
Each block's hash is cryptographically linked to the hash of the block before it. If an attacker tries to change the data in an earlier block, its hash would change. This would invalidate every subsequent block in the chain because their previous_hash field would no longer be correct, breaking the chain and signaling a fraud attempt.

What are the logical steps to mine a new block?
The mining process involves several steps. First, the network selects pending transactions. Next, miners compete to solve the Proof-of-Work puzzle for the new block. The first miner to find a valid proof broadcasts the new block to the network. Other nodes then verify the block's validity before adding it to their own copies of the chain, ensuring consensus.