Minichain Project

Building a conceptual blockchainSearch on YouTubeBookmarkSaved

The deck builds a toy blockchain in Python, called Minichain, to answer five questions:

1. What is a blockchain?
2. What is a transaction?
3. What makes a block?
4. How are blocks connected?
5. When a transaction happens, where does it go? Directly to the block?

The code is in two files: blockchain.py (the Block and Blockchain classes) and app.py (a Flask web API with an HTML front end). The only dependency is Flask==3.0.3.

pip install -r requirements.txt     # Flask==3.0.3
python app.py                       # serves on http://0.0.0.0:5000

TerminologiesSearch on YouTubeBookmarkSaved

• Blockchain: a distributed ledger.
• Transactions: records. "A transaction is simply a record describing a proposed state change or transfer."

TransactionsSearch on YouTubeBookmarkSaved

def add_transaction(self, sender, receiver, amount):
    transaction = {
        "sender": sender,
        "receiver": receiver,
        "amount": amount
    }
    self.pending_transactions.append(transaction)
    return transaction

A transaction here is a Python dict with three fields. It is not written to a block. It is appended to a waiting list.

Mem poolSearch on YouTubeBookmarkSaved

self.pending_transactions = []

pending_transactions plays the role of the mempool (memory pool). A transaction is created first. It is not immediately part of the blockchain. It waits in the mempool until a block is mined.

What is a block?Search on YouTubeBookmarkSaved

class Block:
    def __init__(self, index, timestamp, transactions,
                 previous_hash, nonce=0):
        self.index = index
        self.timestamp = timestamp
        self.transactions = transactions
        self.previous_hash = previous_hash
        self.nonce = nonce
        self.hash = self.calculate_hash()

Hashing a blockSearch on YouTubeBookmarkSaved

def calculate_hash(self):
    block_data = {
        "index": self.index,
        "timestamp": self.timestamp,
        "transactions": self.transactions,
        "previous_hash": self.previous_hash,
        "nonce": self.nonce
    }
    encoded_block = json.dumps(block_data, sort_keys=True).encode()
    return hashlib.sha256(encoded_block).hexdigest()

Steps:

1. Put every field except hash in a dict.
2. Serialise it to JSON with sort_keys=True. Sorting keys makes the string, and so the hash, the same every time for the same data.
3. .encode() turns the string into bytes.
4. hashlib.sha256(...).hexdigest() returns a 64-character hex string (256 bits).

Connecting the blocksSearch on YouTubeBookmarkSaved

previous_hash=self.get_latest_block().hash

When creating a new block, we take the hash of the previous block and store it inside the new block. get_latest_block() returns self.chain[-1]. Because previous_hash is part of the hashed data, each block's hash depends on every block before it.

Genesis blockSearch on YouTubeBookmarkSaved

If every block points to a previous block, where does the chain start?

def create_genesis_block(self):
    genesis_block = Block(
        index=0,
        timestamp=time(),
        transactions=[],
        previous_hash="0"
    )
    self.chain.append(genesis_block)

The genesis block is block 0. It has no transactions and a placeholder previous_hash of "0". The Blockchain constructor creates it automatically:

class Blockchain:
    def __init__(self):
        self.chain = []
        self.pending_transactions = []
        self.difficulty = 3
        self.create_genesis_block()

Pending transactions and block creationSearch on YouTubeBookmarkSaved

self.pending_transactions.append(transaction)          # when a tx arrives
transactions=self.pending_transactions.copy()          # when a block is built

The new block gets a copy of the mempool. After mining, the mempool is emptied (self.pending_transactions = []). Copying matters: clearing the list later must not empty the block's own list.

Who can add the block to the blockchain?Search on YouTubeBookmarkSaved

Anyone could build a block. A blockchain needs a mechanism that makes creating a valid block require computational work. That mechanism is Proof of Work.

Proof of WorkSearch on YouTubeBookmarkSaved

self.difficulty = 3
target = "0" * self.difficulty      # "000"

A block is valid only if its hash starts with difficulty zeros. With difficulty 3, the hash must start with "000".

NonceSearch on YouTubeBookmarkSaved

In the simplified Proof of Work, the nonce is a value we keep changing to generate different hashes.

def mine_pending_transactions(self):
    if len(self.pending_transactions) == 0:
        return None

    new_block = Block(
        index=len(self.chain),
        timestamp=time(),
        transactions=self.pending_transactions.copy(),
        previous_hash=self.get_latest_block().hash
    )

    target = "0" * self.difficulty
    while not new_block.hash.startswith(target):
        new_block.nonce += 1
        new_block.hash = new_block.calculate_hash()

    self.chain.append(new_block)
    self.pending_transactions = []
    return new_block

The mining flow from the deck:

Validation of the blockchainSearch on YouTubeBookmarkSaved

def is_chain_valid(self):
    for i in range(1, len(self.chain)):
        current_block = self.chain[i]
        previous_block = self.chain[i - 1]

        if current_block.hash != current_block.calculate_hash():
            return False
        if current_block.previous_hash != previous_block.hash:
            return False
        if not current_block.hash.startswith("0" * self.difficulty):
            return False
    return True

Three checks for every block after genesis:

Flask routesSearch on YouTubeBookmarkSaved

app.py wraps one Blockchain() object in a Flask app:

app = Flask(__name__)
blockchain = Blockchain()

@app.route("/transactions", methods=["POST"])
def create_transaction():
    data = request.get_json()
    sender = data.get("sender")
    receiver = data.get("receiver")
    amount = data.get("amount")
    if not sender or not receiver or amount is None:
        return jsonify({"error": "Sender, receiver and amount are required"}), 400
    transaction = blockchain.add_transaction(sender, receiver, amount)
    return jsonify({
        "message": "Transaction added successfully",
        "transaction": transaction,
        "pending_transactions": len(blockchain.pending_transactions)
    }), 201

The /tamper route refuses the genesis block (index 0), a block index that does not exist, and a block with no transactions. It changes sender, receiver or amount of the first transaction. It can also overwrite block.hash directly.

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=True)

Trying the APISearch on YouTubeBookmarkSaved

curl -X POST localhost:5000/transactions -H "Content-Type: application/json" \
     -d '{"sender":"Alice","receiver":"Bob","amount":10}'
curl localhost:5000/pending
curl -X POST localhost:5000/mine
curl localhost:5000/chain
curl localhost:5000/validate                    # {"valid": true}
curl -X POST localhost:5000/tamper -H "Content-Type: application/json" \
     -d '{"block_index":1,"amount":1000}'
curl localhost:5000/validate                    # {"valid": false}

Now the real game: blockchain networksSearch on YouTubeBookmarkSaved

Major families of blockchain networksSearch on YouTubeBookmarkSaved

Types of blockchainSearch on YouTubeBookmarkSaved

Mainnet vs testnetSearch on YouTubeBookmarkSaved

Mainnet is the live production network where real transactions occur and tokens have real value (for example Bitcoin's mainnet). Testnet is a separate parallel network for testing. It mimics mainnet but uses worthless test tokens, often free from a faucet. Developers deploy contracts and catch bugs without risking real money.

Layer 1, Layer 2 and overlay networksSearch on YouTubeBookmarkSaved

Layer 1 (L1) is the base blockchain where transactions are permanently recorded and verified by everyone. Examples: Bitcoin, Ethereum. It confirms and secures every transaction and keeps a permanent, tamper-proof record. It depends on no other network; it is the source of truth. The catch: the whole network checks every transaction, so L1s are slow and expensive under heavy use.

Layer 2 (L2) is a separate system on top of an L1. It handles transactions faster and cheaper but relies on the L1 for final security. Examples: Lightning Network (on Bitcoin), Arbitrum and Polygon (on Ethereum). How it works:

1. Users do many transactions on the L2, fast and nearly free.
2. The L2 periodically bundles them and sends a short summary to the L1.
3. The L1 checks and locks in the summary, making it official and secure.

An overlay network runs on top of an existing blockchain but mainly adds a new feature or use case, not speed. Examples on Bitcoin: Lightning Network (also called an overlay; instant micropayments), Ordinals / BRC-20 (tokens and NFT-like functions), Counterparty (asset trading). Key idea: an overlay does not change the base chain. It uses the L1 as a foundation and adds rules that only overlay-aware software interprets.

Quick self-testSearch on YouTubeBookmarkSaved