Technical & Protocol

Proof of Work is a consensus mechanism requiring network participants — known as miners — to expend computational effort solving a cryptographic puzzle in order to propose and validate new blocks on a blockchain. The first miner to solve the puzzle broadcasts the solution to the network, earns the block reward, and appends the new block to the chain. The difficulty of the puzzle adjusts dynamically to maintain a consistent block production rate regardless of total network hash power.

Proof of Stake is a consensus mechanism in which validators are selected to propose and attest to new blocks in proportion to the amount of cryptocurrency they have staked — locked as collateral — in the network. Validators who behave dishonestly risk having their staked assets slashed (partially or fully destroyed), creating an economic disincentive for malicious behavior without requiring energy-intensive computation. PoS variants include Delegated Proof of Stake (DPoS), Nominated Proof of Stake (NPoS), and Liquid Proof of Stake (LPoS).

Byzantine Fault Tolerance describes the ability of a distributed computing system to continue operating correctly even when some of its nodes fail or act maliciously — sending conflicting or false information to different parts of the network. The term derives from the Byzantine Generals Problem, a thought experiment formalized by Lamport, Shostak, and Pease (1982) in which generals must coordinate an attack via messengers who may be traitors. A system is BFT if it can reach consensus despite up to one-third of its nodes being faulty or adversarial.

Nakamoto Consensus is the consensus model introduced in the Bitcoin whitepaper (2008), combining Proof of Work with the longest-chain rule to achieve agreement in a permissionless, trustless network. Under this model, nodes always extend the chain with the most accumulated proof-of-work (the "heaviest" chain), and transaction finality is probabilistic rather than absolute — a transaction becomes increasingly irreversible as more blocks are appended after it. The model achieves Sybil resistance through computational cost rather than identity verification.

A hash function is a deterministic mathematical algorithm that maps an input of arbitrary length to a fixed-length output — called a hash, digest, or fingerprint. Cryptographic hash functions used in blockchain systems must satisfy four properties: (1) determinism — the same input always produces the same output; (2) pre-image resistance — it is computationally infeasible to reverse the function; (3) collision resistance — it is computationally infeasible to find two distinct inputs producing the same output; (4) avalanche effect — a minor change in input produces a drastically different output.

ECDSA is the digital signature algorithm used by Bitcoin, Ethereum (pre-EIP-2098), and many other blockchain networks to authenticate transactions. It is based on elliptic curve cryptography (ECC), which provides equivalent security to RSA at significantly smaller key sizes. In blockchain contexts, ECDSA operates over the secp256k1 elliptic curve, generating a 256-bit private key from which a corresponding public key and wallet address are derived. A valid ECDSA signature proves that the signer possesses the private key corresponding to the signing address without revealing the key itself.

A zero-knowledge proof is a cryptographic protocol by which one party (the prover) can demonstrate to another party (the verifier) that a statement is true without conveying any information beyond the validity of the statement itself. In blockchain applications, ZKPs enable privacy-preserving transactions, scalable computation verification, and identity attestation without disclosure of underlying data. The three required properties are: completeness (an honest prover can always convince an honest verifier), soundness (a dishonest prover cannot convince a verifier of a false statement), and zero-knowledge (the verifier learns nothing beyond the truth of the statement).

A Merkle tree is a binary tree data structure in which every leaf node contains the cryptographic hash of a data block, and every non-leaf node contains the hash of its two child nodes. The root of the tree — the Merkle root — is a single hash that cryptographically commits to all data in the tree. Any modification to any leaf node propagates upward, changing the Merkle root, making tampering immediately detectable. In Bitcoin, the Merkle root of all transactions in a block is stored in the block header, enabling Simplified Payment Verification (SPV) — the ability to verify a transaction's inclusion in a block without downloading the full blockchain.

An Unspent Transaction Output (UTXO) is the fundamental unit of value in Bitcoin's accounting model. Every Bitcoin transaction consumes one or more UTXOs as inputs and creates one or more new UTXOs as outputs. A UTXO represents a discrete, indivisible chunk of bitcoin that has been received but not yet spent. The set of all UTXOs in existence at any given time constitutes the UTXO set — the complete record of all spendable bitcoin. To spend a UTXO, the owner must provide a valid cryptographic signature proving ownership of the corresponding private key.

The mempool (memory pool) is a node-local data structure that holds unconfirmed transactions that have been broadcast to the network but not yet included in a block. Each full node maintains its own mempool, and mempools across the network may differ slightly due to propagation delays and individual node policies. Miners and validators select transactions from the mempool to include in the next block, typically prioritizing those offering the highest fee per unit of block space (sat/vByte in Bitcoin; gwei in Ethereum).

The genesis block is the first block in a blockchain — Block 0 — hardcoded into the protocol software rather than mined or validated through the normal consensus process. It serves as the immutable anchor of the entire chain; every subsequent block references its predecessor back to the genesis block, establishing the chain's provenance. Because it has no predecessor, the genesis block's "previous block hash" field contains a null value or zeroed hash.

A smart contract is a self-executing program stored on a blockchain whose terms are directly written in code. Upon satisfaction of predefined conditions, the contract executes automatically without the need for intermediaries. The term was coined by legal scholar and cryptographer Nick Szabo in 1994, predating blockchain technology itself. In contemporary usage, smart contracts are most commonly deployed on the Ethereum Virtual Machine (EVM) and compatible networks.

The Ethereum Virtual Machine (EVM) is a quasi-Turing-complete, stack-based virtual machine that serves as the decentralized computation engine of the Ethereum network. Every Ethereum full node runs an identical instance of the EVM, executing smart contract bytecode deterministically so that all nodes reach the same state after processing each transaction. The EVM operates on a 256-bit word size, processes 140+ opcodes, and uses a gas metering system to bound computation and prevent infinite loops.

Gas is the unit measuring the computational effort required to execute specific operations on the Ethereum network. Every EVM opcode has an assigned gas cost; the total gas consumed by a transaction is the sum of all opcode costs. Users specify a gas limit (maximum gas they are willing to consume) and a gas price (amount of ETH per unit of gas). The transaction fee paid to validators equals gas used × gas price. If a transaction runs out of gas before completion, it reverts — but the gas consumed up to that point is not refunded.

Solidity is a statically-typed, contract-oriented, high-level programming language designed for writing smart contracts on the Ethereum Virtual Machine. Its syntax is influenced by JavaScript, Python, and C++. Solidity source code is compiled to EVM bytecode by the solc compiler. Key language features include contract inheritance, function modifiers, events, custom error types, and native support for Ethereum data types (address, uint256, bytes32). Solidity is the dominant language for DeFi protocols, NFT contracts, and DAO governance systems.

In blockchain contexts, an oracle is a service that provides smart contracts with external, real-world data that does not exist natively on-chain — such as asset prices, weather data, sports outcomes, or random number seeds. Because blockchains are deterministic, closed systems, smart contracts cannot natively access off-chain information; oracles serve as the bridge between on-chain logic and off-chain reality. The reliability and security of an oracle directly determines the security of any smart contract that depends on its data.

A peer-to-peer (P2P) network is a distributed network architecture in which participants (peers) communicate directly with one another without routing through a central server or authority. Each peer is simultaneously a client and a server, sharing resources and responsibilities equally. Blockchain networks are built on P2P architecture to eliminate single points of failure and censorship. Nodes discover peers through bootstrapping mechanisms (DNS seeds, hardcoded peer lists) and maintain connections to a subset of the network, propagating transactions and blocks via a gossip protocol.

A fork is a change to a blockchain's protocol rules that causes a divergence in the chain. A hard fork is a backward-incompatible rule change: nodes that do not upgrade will reject blocks produced under the new rules, potentially resulting in two separate chains (e.g., Ethereum / Ethereum Classic after the 2016 DAO hack). A soft fork is a backward-compatible tightening of rules: upgraded nodes produce blocks that non-upgraded nodes still accept, allowing gradual adoption without a chain split (e.g., Bitcoin's SegWit upgrade, 2017).