How to Build a Simple Blockchain with Hash Chaining in Python

What Is a Blockchain? Understanding the Immutable Ledger and Block Structure

Welcome to the world of blockchain technology. In this masterclass we’ll demystify the immutable ledger that powers cryptocurrencies and decentralized applications, and explore how the block structure ensures data integrity.

{
  "index": 1,
  "previousHash": "0",
  "timestamp": 1577838753,
  "data": "First block",
  "hash": "9e5c8b7f..."
}

Key Takeaways

• Immutable ledger: Once data is written, it cannot be altered without changing all subsequent blocks.
• Block structure: Each block contains a list of transactions, a timestamp, and the hash of the previous block.
• Cryptographic linking: The merkle tree structure within each block provides efficient verification.
• Decentralization: Multiple nodes maintain copies of the chain, ensuring no single point of failure.

Core Principles: Decentralization, Trustlessness, and the Immutable Ledger Concept

In modern IT infrastructure, the shift toward decentralized, trustless systems underpins the reliability and security of distributed applications. Understanding these principles is essential for designing resilient architectures.

Decentralization: Removing the Single Point of Control

Decentralization distributes authority across multiple nodes, eliminating a central gatekeeper and fostering fault tolerance.

Trustlessness: Cryptographic Guarantees Replace Human Trust

Trustlessness leverages mathematical proofs and digital signatures so that participants can verify data without needing to trust any single entity.

Immutable Ledger: The Bedrock of Blockchain

An immutable ledger ensures that once data is written, it cannot be altered without changing all subsequent blocks, providing a tamper‑evident record.

Comparison: Decentralized vs Centralized Systems

Key Takeaways

• Decentralization eliminates reliance on a single authority, enhancing resilience.
• Trustlessness uses cryptographic proofs to ensure data integrity without trusting any participant.
• Immutable Ledger guarantees that once data is written, it cannot be altered without consensus.
• Together, these principles enable secure, transparent, and resilient IT infrastructures.

Cryptographic Hash Functions Explained: The Engine Behind Hash Chaining

Intro Hook

Hash functions are the silent workhorses that turn any piece of data into a fixed‑size fingerprint. This fingerprint powers everything from password storage to blockchain linking to other masterclasses if they relate to the current text.

Block Anatomy: Designing the Block Structure for a Python Blockchain

Intro Hook

Hash functions are the silent workhorses that turn any piece of data into a fixed‑size fingerprint. This fingerprint powers everything from password storage to blockchain linking, and it is the core of every how merkle trees secure blockchain.

Key Takeaways

• Index: Unique identifier for the block within the chain.
• Timestamp: Records when the block was created, enabling chronological ordering.
• Data: The actual payload (transactions, records, etc.) that the block carries.
• Previous Hash: Links the current block to its predecessor, forming the immutable chain.
• Nonce: A variable value adjusted by miners to find a valid hash target.

Python Block Class Example

 class Block: def __init__(self, index, timestamp, data, previous_hash, nonce): self.index = index self.timestamp = timestamp self.data = data self.previous_hash = previous_hash self.nonce = nonce 

Hash Chaining Explained: Linking Blocks to Create an Immutable Chain

In blockchain technology, each block is cryptographically linked to its predecessor, forming an immutable chain that guarantees data integrity.

class Block:
    def __init__(self, index, timestamp, data, previous_hash, nonce):
        self.index = index
        self.timestamp = timestamp
        self.data = data
        self.previous_hash = previous_hash
        self.nonce = nonce

Key Takeaways

The previous_hash of a block stores the cryptographic hash of its predecessor, creating a chain where any alteration breaks the link and invalidates the entire sequence.

Building the Blockchain: Creating the Genesis Block and Adding New Blocks

Every blockchain begins with a single block: the Genesis Block. This is the foundational unit of the chain and acts as the root from which all other blocks are linked. In this section, we'll walk through how to programmatically create the first block and then add new blocks to the chain, ensuring each block references the previous one to maintain immutability.

Pro Tip: The Genesis Block is the first block in any blockchain. It is hardcoded and does not reference a previous block, making it the anchor of the entire chain.

 Block Data: Sample block data for hashing demonstration SHA-256 Hash: <span style="background:#ffeb3b;">3a7bd3e2360a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2</span> 

Step-by-Step Block Creation

Let's break down the process of building a blockchain from scratch:

1. Genesis Block Creation: The first step is to create the Genesis Block. This block is unique because it has no previous block to reference. It is manually created with a predefined set of data, often hardcoded into the system.
2. Adding New Blocks: Each new block must reference the previous block's hash to maintain the chain's integrity. This ensures that any change to a block will break the chain, making tampering evident.
3. Chain Validation: The blockchain must validate each new block by checking that the previous_hash matches the hash of the last block in the chain.

Here's a simplified Python implementation of a blockchain:

class Block: def __init__(self, index, timestamp, data, previous_hash): self.index = index self.timestamp = timestamp self.data = data self.previous_hash = previous_hash self.hash = self.calculate_hash() def calculate_hash(self): # Simple hash calculation for demonstration import hashlib block_content = str(self.index) + str(self.timestamp) + str(self.data) + self.previous_hash return hashlib.sha256(block_content.encode('utf-8')).hexdigest()

Key Takeaways

• The Genesis Block is the first block in a blockchain and is manually created with no previous reference.
• Each subsequent block must reference the previous block's hash to maintain the chain's integrity.
• Any change to a block's data will break the chain, ensuring immutability.

Pro Tip: The previous_hash attribute creates an immutable link between blocks, ensuring that any alteration to a block's data invalidates the entire chain and preserves integrity. Learn more about how Merkle trees secure blockchain.

Simple proof-of-work chains suffer from three critical limitations:

1. Fixed block intervals create congestion during high demand
2. Fixed block rewards don't scale with network activity
3. Limited block capacity creates bottlenecks for data-intensive applications

Consider this simplified mining loop that works in isolation but fails under load:

 import hashlib
 def mine(previous_hash, data, nonce, target):
     block_string = f'{previous_hash}{data}{nonce}'
     block_hash = hashlib.sha256(block_string.encode()).hexdigest()
     if block_hash < target:
         return block_hash, nonce
     return None, None

This naive approach lacks critical optimizations that real-world chains implement:

Learn how Merkle trees address data structure limitations