How to Build a Blockchain in Python

Before explaining how to build a blockchain in Python, let's revisit the origins of blockchain technology. In 2008, an author (or authors) under the pseudonym Satoshi Nakamoto released a groundbreaking white paper describing a peer-to-peer electronic cash system. This system eliminated the need for third-party verification by timestamping and hashing transactions into an ongoing chain of proof-of-work.

Understanding Blockchain Fundamentals

What is a Blockchain?

A blockchain is a growing list of records (blocks) linked together using cryptography. While Bitcoin was the first successful application of this system, the technology isn't limited to financial transactions. The data stored in a blockchain must have these critical characteristics:

Immutable: Cannot be altered after recording
Secure: Resistant to hacking attempts
Persistent: No data loss over time
Distributed: Shared across a network

These qualities maintain blockchain integrity and network security. Let's explore how to implement these principles in Python.

Building Your Python Blockchain

Blockchain Structure Essentials

Each block in our Python blockchain will store data in JSON format:

{
    "author": "author_name",
    "timestamp": "transaction_time",
    "data": "transaction_data"
}

Creating the Block Class

We'll start by defining a Block class with essential attributes:

from hashlib import sha256
import json

class Block:
    def __init__(self, index, transactions, timestamp, previous_hash, nonce=0):
        self.index = index
        self.transactions = transactions
        self.timestamp = timestamp
        self.previous_hash = previous_hash
        self.nonce = nonce
    
    def compute_hash(self):
        block_string = json.dumps(self.__dict__, sort_keys=True)
        return sha256(block_string.encode()).hexdigest()

The compute_hash method ensures each block's immutability using SHA-256 cryptographic hashing.

Implementing the Blockchain

Our Blockchain class will manage the chain of blocks:

import time

class Blockchain:
    def __init__(self):
        self.unconfirmed_transactions = []
        self.chain = []
        self.create_genesis_block()
    
    def create_genesis_block(self):
        genesis_block = Block(0, [], time.time(), "0")
        genesis_block.hash = genesis_block.compute_hash()
        self.chain.append(genesis_block)
    
    @property
    def last_block(self):
        return self.chain[-1]

Proof-of-Work System

To secure our blockchain, we implement a proof-of-work system:

difficulty = 2

def proof_of_work(self, block):
    block.nonce = 0
    computed_hash = block.compute_hash()
    while not computed_hash.startswith('0' * Blockchain.difficulty):
        block.nonce += 1
        computed_hash = block.compute_hash()
    return computed_hash

This system progressively increases computational difficulty, making tampering with previous blocks impractical.

Mining Blocks and Adding Transactions

The mining process confirms transactions and adds new blocks:

def add_block(self, block, proof):
    previous_hash = self.last_block.hash
    if previous_hash != block.previous_hash:
        return False
    if not self.is_valid_proof(block, proof):
        return False
    block.hash = proof
    self.chain.append(block)
    return True

def mine(self):
    if not self.unconfirmed_transactions:
        return False
    last_block = self.last_block
    new_block = Block(index=last_block.index + 1,
                    transactions=self.unconfirmed_transactions,
                    timestamp=time.time(),
                    previous_hash=last_block.hash)
    proof = self.proof_of_work(new_block)
    self.add_block(new_block, proof)
    self.unconfirmed_transactions = []
    return new_block.index

Creating a Blockchain API with Flask

Let's expose our blockchain through a REST API:

from flask import Flask, request
import requests

app = Flask(__name__)
blockchain = Blockchain()

@app.route('/chain', methods=['GET'])
def get_chain():
    chain_data = []
    for block in blockchain.chain:
        chain_data.append(block.__dict__)
    return json.dumps({"length": len(chain_data),
                     "chain": chain_data})

app.run(debug=True, port=5000)

Testing Your Blockchain

After starting the application (python3 Blockchain.py), query the chain:

curl http://127.0.0.1:5000/chain

You'll receive JSON output containing all blockchain data, starting with the genesis block.

Key Takeaways for Python Blockchain Development

Blockchain fundamentals require immutable, secure data storage
Cryptographic hashing ensures block integrity
Proof-of-work systems prevent tampering
Mining processes validate new transactions
REST APIs enable blockchain interaction

👉 Explore advanced blockchain development with comprehensive tools and resources.

Frequently Asked Questions

What makes blockchain secure?

Blockchain security comes from cryptographic hashing and distributed consensus mechanisms that make tampering computationally impractical.

How long does it take to mine a block?

Mining time varies based on difficulty settings and computational power. Our example uses a difficulty of 2 leading zeros.

Can I modify this code for cryptocurrency?

Yes, this foundation can be extended to create a cryptocurrency by adding wallet functionality and transaction validation rules.

Why use Python for blockchain?

Python's readability and extensive libraries make it ideal for prototyping blockchain concepts, though production systems often use performance-optimized languages.

How does proof-of-work prevent spam?

The computational work required to create valid blocks discourages spam by making it resource-intensive to submit invalid transactions.

👉 Learn more about blockchain implementation with practical examples and expert guidance.