Blockchain core components: nodes, blocks, hashes, and consensus

A blockchain is a shared record that a network accepts through agreed rules. The components matter because each one answers a different question: what changed, who checked it, how the record connects to earlier data, and why nodes accept one history.

Bitcoin’s developer guide describes the chain as an ordered record of transactions that protects against changing earlier records and spending the same funds twice. Ethereum documentation adds an important boundary: full nodes validate blocks and state data, while consensus mechanisms coordinate agreement across the network.

How the components work together

A transaction begins the flow by asking the network to change a defined piece of state, after which nodes check the request against protocol rules, a block producer groups valid data into a proposed block, and consensus determines whether that block becomes part of the accepted history.

The flow is a model rather than a fixed implementation, because Bitcoin, Ethereum, and permissioned ledgers assign validation and block-production work differently, so you should inspect the rules of the network you plan to use.

Nodes keep and verify the ledger

A node is software that participates in a blockchain network. It can relay transactions and blocks, store data, and validate protocol rules, although a node’s exact duties depend on the client and network configuration.

Ethereum’s documentation distinguishes full nodes from lighter client modes. The distinction explains why copied data and independently verified data are different operational states.

Full nodes validate history

A full node validates the chain block by block rather than accepting a peer’s summary. That verification matters because a node rejects data that fails the protocol’s checks.

Transactions describe a requested state change

A transaction carries the data that asks the network to update its state. In a cryptocurrency network, that can transfer value. In a smart-contract network, it can call a contract function or deploy contract code.

Nodes validate a transaction before it belongs in a proposed block. The checks can include a valid signature, available funds, nonce ordering, fee rules, and the contract’s execution result, depending on the protocol.

Blocks group accepted transaction data

A block packages transaction data with metadata. The metadata commonly includes a reference to an earlier block, which gives the ledger an ordered history rather than an unrelated collection of records.

Bitcoin’s reference documentation shows why block headers matter: the serialized header participates in proof of work and therefore belongs to the consensus rules. A block does not become authoritative only because a producer assembled it.

Hashes connect blocks and expose edits

A cryptographic hash converts input data into a fixed-length digest. When a block records the digest of the preceding block, changing old data changes its digest and breaks the connection that later blocks expect.

I ran the small Python example below with Python 3.13.5. It accepts a two-block chain, changes one transaction after the hash was stored, and reports that the altered chain fails its local consistency check.

from __future__ import annotations

import hashlib
import json


def digest(index: int, previous_hash: str, transactions: list[str]) -> str:
    payload = json.dumps(
        {"index": index, "previous_hash": previous_hash, "transactions": transactions},
        sort_keys=True,
        separators=(",", ":"),
    )
    return hashlib.sha256(payload.encode()).hexdigest()


def make_block(index: int, previous_hash: str, transactions: list[str]) -> dict[str, object]:
    return {
        "index": index,
        "previous_hash": previous_hash,
        "transactions": transactions,
        "hash": digest(index, previous_hash, transactions),
    }


def chain_is_valid(chain: list[dict[str, object]]) -> bool:
    for index, block in enumerate(chain):
        if block["hash"] != digest(block["index"], block["previous_hash"], block["transactions"]):
            return False
        if index and block["previous_hash"] != chain[index - 1]["hash"]:
            return False
    return True


first = make_block(0, "0" * 64, ["Ava pays Bo 2"])
second = make_block(1, first["hash"], ["Bo pays Cy 1"])
chain = [first, second]
print("valid before edit:", chain_is_valid(chain))
chain[0]["transactions"] = ["Ava pays Bo 20"]
print("valid after edit: ", chain_is_valid(chain))

Save the file as hash_chain_demo.py and run the command below.

python3 hash_chain_demo.py

The result proves only that this local program detects a changed record. A hash chain does not by itself distribute data, identify participants, resolve competing histories, or protect a network whose validators accept malicious rules.

Consensus chooses an accepted history

Consensus is the set of protocol rules and incentives that lets independent nodes converge on an accepted state. Proof of work is one design. Ethereum now uses proof of stake, and permissioned networks can use other agreement models.

The strongest objection to a component list is that it can make every blockchain sound interchangeable. That objection holds because security, throughput, finality, and who may validate transactions come from the network’s consensus and governance rules, not from the presence of blocks alone.

Choose the component boundary that matters

Start with the transaction rules and then inspect who validates them, how a block becomes accepted, and which nodes retain the history. If your application has one trusted operator and ordinary access control solves the audit requirement, a database is usually the simpler fit.

For a network design, read the protocol’s node and consensus documentation before copying a Bitcoin-style diagram into a different system. The components describe a mechanism. The network’s rules decide what that mechanism guarantees.

Sources

• Bitcoin Developer Guide: Block Chain
• Bitcoin Developer Reference: Block Chain
• Ethereum: Nodes and clients
• Ethereum: Consensus mechanisms
• Hyperledger Fabric: The ledger