Web3 Glossary

All words and definitions related to Blockchain and Ethereum.

For more details check out the Ethereum Wiki and the Ethereum Book Glossary.



An account is an object containing an address, balance, nonce, optional storage, and code. It can be a contract account or an externally owned account (EOA).


An address is the representation of a public key belonging to a particular user. Addresses are essentially contracts that can receive or send transactions on the blockchain. Note that in practice, the address is technically the hash of a public key (the rightmost 160 bits of a Keccak hash of an ECDSA public key).


In Ethereum, a blockchain is a sequence of blocks validated by the proof-of-work system, each linking to its predecessor all the way to the genesis block. This varies from the Bitcoin protocol in that it does not have a block size limit; it instead uses varying gas limits.


A block is a package of data that contains zero or more transactions; the hash of the previous block (“parent”); and optionally other data. Because each block (except for the initial “genesis block”) points to the previous block, the data structure that they form is called a “blockchain”.


When numerous nodes—usually most nodes on the network—all have the same blocks in their locally validated best blockchain they have achieved consensus.


Decentralized Autonomous Organization. A company or other organization that operates without hierarchical management. It is a form of legal structure that has no central governing body and whose members share a common goal to act in the best interest of the entity. DAOs are enabled by Smart Contract technology.

DApp (Decentralized Application)

Decentralized application. Basically, any app that is built using blockchain infrastructure. At a minimum, it is a smart contract and a web user interface. More broadly, a DApp is a web application that is built on top of open, decentralized, peer-to-peer infrastructure services. In addition, many DApps include decentralized storage and/or a message protocol and platform.


Decentralized finance (DeFi) uses Blockchain Smart Contracts to remove third parties and centralized institutions (Banks) from financial transactions.

Double Spend

A double spend is a deliberate fork, where a user with a large amount of mining power sends a transaction to purchase some product, then after receiving the product creates another transaction sending the same coins to themselves. The attacker then creates a block, at the same level as the block containing the original transaction but containing the second transaction instead, and starts mining on the fork. If the attacker has more than 50% of all mining power, the double-spend is guaranteed to succeed eventually at any block depth. Below 50%, there is some probability of success, but it is usually only substantial at a depth up to about 2-5. For this reason, most cryptocurrency exchanges, gambling sites, and financial services wait until six blocks have been produced (“six confirmations”) before accepting a payment.


A service that dispenses funds in the form of free test tokens that can be used on a testnet of its corresponding blockchain.


A fork occurs when two blocks are generated pointing to the same block as their parent, and some portion of miners see one block first and some see the other. This may lead to two blockchains growing at the same time. Generally, it is mathematically near-certain that a fork will resolve itself within four blocks as miners on one chain will eventually get lucky and that chain will grow longer and all miners switch to it; however, forks may last longer if miners disagree on whether or not a particular block is valid.


The history is the past transactions and blocks. Note that the state is a deterministic function of history.

Light Client

A Light client is a client that downloads only a small part of the blockchain, allowing users of low-power or low-storage hardware like smartphones and laptops to maintain almost the same guarantee of security by selectively downloading small parts of the state without needing to spend megabytes of bandwidth and gigabytes of storage on full blockchain validation and maintenance.


Mining is the process of repeatedly aggregating transactions, constructing a block and trying different nonces until a nonce is found that satisfies the proof of work condition. If a miner gets lucky and produces a valid block, they are granted a certain number of coins as a reward as well as all of the transaction fees in the block. Once the valid block is found, all miners start trying to create a new block containing the hash of the newly generated block as their parent.


The post-state of a block is the state after executing all transactions in the ancestors of the block, starting from the genesis going up to and including the transactions in that block itself.

Proof of Work

Proof of Work is the concept of requiring a non-insignificant but feasible amount of effort to produce some result. In Bitcoin, Ethereum, and many other crypto-ledgers, this means finding a hash that is smaller than some target value.

The reason this is necessary is that in a decentralized system anyone can produce blocks, so in order to prevent the network from being flooded with blocks, and to provide a way of measuring consensus behind a particular version of the blockchain, it must in some way be hard to produce a block.

Because hashes are pseudorandom, finding a block whose hash is less than 0000000100000000000000000000000000000000000000000000000000000000 takes an average of 4.3 billion attempts. In all such systems, the target value self-adjusts so that on average one node in the network finds a block every N minutes (eg. N = 10 for Bitcoin and 1 for Ethereum).

Proof of Work Nonce

A proof of work nonce is a technically meaningless (but super necessary) value in a block to show that the block satisfies the proof of work condition.


A stale is a block that is created when there is already another block with the same parent out there; stales typically get discarded and are wasted effort.


A state is the set of data that represents information currently relevant to applications on the chain. A blockchain network strictly needs to keep track of the state of the chain.

In a currency, this is simply balances; in more complex applications this could refer to other data structures that the application in question needs to keep track of (e.g. who has a what domain name, what is the status of a given contract, etc).


A transaction is a digitally signed message authorizing some particular action associated with the blockchain. In a currency, the dominant transaction type is sending currency units or tokens to someone else; in other systems, actions like registering domain names, making and fulfilling trade offers, and entering into contracts are also valid transaction types.


Software that holds secret keys. Used to access and control Ethereum accounts and interact with smart contracts. Keys need not be stored in a wallet, and can instead be retrieved from offline storage (e.g., a memory card or paper) for improved security. Despite the name, wallets never store the actual coins or tokens.


The third version of the web. First proposed by Dr. Gavin Wood, Web3 represents a new vision and focus for web applications: from centrally owned and managed applications, to applications built on decentralized protocols.

Ethereum Blockchain

Account Nonce

An account nonce is a transaction counter in each account. This prevents replay attacks. For example, a transaction sending 20 coins from A to B can be replayed by B over and over to continually drain A’s balance, but the account nonce can prevent that.


Instructions or code are expressed in a numeric format such that a virtual machine can efficiently interpret them.


A contract is an account that contains, and is controlled by EVM code. Contracts cannot be controlled by private keys directly unless built into the EVM code, a contract has no owner once released.

Contract Creation Transaction

A special transaction, with the "zero address" as the recipient, is used to register a contract and record it on the Ethereum blockchain.


Ethereum Improvement Proposals (EIPs) describe standards for the Ethereum platform, including core protocol specifications, client APIs, and contract standards.


Ethereum Name Service (ENS) takes the exact same concept as the Domain Name Service (DNS) but adjusts it for the needs of Ethereum users. The Ethereum Name Service (ENS) is a distributed, open, and extensible naming system based on the Ethereum blockchain.

ENS’s job is to map human-readable names like ‘alice.eth’ to machine-readable identifiers such as Ethereum addresses, other cryptocurrency addresses, content hashes, and metadata.


Ether is the primary internal cryptographic token of the Ethereum network. Ether is used to pay transaction and computation fees for Ethereum transactions.

EVM Code

EVM code stands for Ethereum Virtual Machine code. It is the programming language in which accounts on the Ethereum blockchain can contain code. The EVM code associated with an account is executed every time a message is sent to that account, and has the ability to read/write storage and send messages itself.

Externally Owned Account

An externally owned account is an account controlled by a private key. Externally owned accounts cannot contain EVM code.


Gas is a measurement roughly equivalent to computational steps. Every transaction is required to include a gas limit and a fee that it is willing to pay per gas; miners have the choice of including the transaction and collecting the fee or not.

If the total number of gas used by the computation spawned by the transaction, including the original message and any sub-messages that may be triggered, is less than or equal to the gas limit, then the transaction processes. If the total gas exceeds the gas limit, then all changes are reverted, except that the transaction is still valid and the fee can still be collected by the miner. Every operation has a gas expenditure; for most operations, it is ~3-10, although some expensive operations have expenditures up to 700 and a transaction itself has an expenditure of 21000.

Genesis Block

The genesis block is the first ever block recorded on its respective blockchain network.


Go Ethereum. One of the most prominent implementations of the Ethereum protocol, is written in Go.


A gwei or gigawei is defined as 1,000,000,000 wei. One gwei equals 0.000000001 or 10-9 ETH.

Hard Fork

Hard forks are backward-incompatible permanent divergence in a blockchain. Typically, these occur when nodes add new rules in a way that conflicts with the rules of old nodes. The breakaway fork thus becomes a new implementation of a new set of rules for the Blockchain.

HD wallet

A wallet using the hierarchical deterministic (HD) key creation and transfer protocol (BIP-32).

HD wallet seed

A value used to generate the master private key and master chain code for an HD wallet. The wallet seed can be represented by mnemonic words, making it easier for humans to copy, back up, and restore private keys.

Impermanent Loss

Impermanent loss happens when you provide liquidity to a liquidity pool, and the price of your deposited assets changes compared to when you deposited them.

InterPlanetary File System (IPFS)

A protocol, network, and open source project designed to create a content-addressable, peer-to-peer method of storing and sharing hypermedia in a distributed filesystem.


Mainnet is a term used to describe a working, fully-operational blockchain. A mainnet network has been fully deployed and is in production, like the Bitcoin and Ethereum blockchains. In a mainnet, cryptocurrency transactions are verified and recorded to the blockchain.

Merkle-Patricia tree (or trie)

A Merkle tree is a data structure that stores the state of every account. The trie is built by starting from each individual node, then splitting the nodes into groups of up to 16 and hashing each group, then making hashes of hashes, and so forth until there is one final “root hash” for the entire trie.

The trie has these important properties:

  1. There is exactly one possible trie and therefore one possible root hash for each set of data.
  2. It is very easy to update, add or remove nodes in the trie and generate the new root hash.
  3. There is no way to modify any part of the tree without changing the root hash, so if the root hash is included in a signed document or a valid block, the signature or proof of work secures the entire tree
  4. One can provide just the “branch” of a tree going down to a particular node as cryptographic proof that that node is indeed in the tree with that exact content.

Merkle trees are also used to store the internal storage of accounts as well as transactions and ommers. See here for a more detailed description.


A message is a sort of “virtual transaction” sent by EVM code from one account to another.

It's important to note that “transactions” and “messages” in Ethereum are different. A “transaction” in Ethereum parlance specifically refers to a digitally signed piece of data, originating from a source other than executing EVM code, to be recorded in the blockchain. Every transaction triggers an associated message, but messages can also be sent by EVM code, in which case they are never represented in data anywhere.

Non-Fungible Token (NFT)

This is a token standard introduced by the ERC721 proposal. NFTs can be tracked and traded, but each token is unique and distinct; they are not interchangeable like ERC20 tokens. NFTs can represent ownership of digital or physical assets.


An ommer is a child of a parent of a parent of a block that is not the parent, or, in other words, a child of an ancestor that is not itself an ancestor. If A is an ommer of B, B is a nibling (niece/nephew) of A.** **When a miner finds a valid block, another miner may have published a competing block which is added to the tip of the blockchain. Unlike with Bitcoin, orphaned blocks in Ethereum can be included by newer blocks as ommers and receive a partial block reward.

Re-entrancy attack

Re-entrancy is a smart contract vulnerability. Reentrancy attacks occur when a smart contract function temporarily gives up control flow of the transaction by making an external call to a contract that is sometimes written by unknown or possibly hostile actors. This permits the latter contract to make a recursive call back to the primary smart contract function to drain its funds.


An amount of ether is included in each new block as a reward by the network to the miner who found the proof-of-work solution


Serialization is the process of converting a data structure into a sequence of bytes. Ethereum internally uses an encoding format called recursive-length prefix encoding (RLP), described here.


Storage is a key/value database contained in each account, where keys and values are both 32-byte strings but can otherwise contain anything.


Short for "test network," a network used to simulate the behavior of the main Ethereum network.


Data committed to the Ethereum Blockchain signed by an originating account, targeting a specific address. The transaction contains metadata such as the gas limit for that transaction.


See Ommer, the gender-neutral alternative to aunt/uncle.

Uncle Blocks

Uncle blocks are similar to orphan blocks but have subtle distinctions connected with the Ethereum protocol. Uncle blocks are valid blocks that the network has rejected. Miners get paid for producing an uncle block, unlike an orphan block, where miners don't get rewarded.\

Learn more about on this page:what-are-uncle-blocks.

Uncle Inclusion Mechanism

The Uncle inclusion mechanism allows a block to include its uncles. This ensures that miners that create blocks that do not quite get included in the main chain can still get rewarded.


The smallest denomination of ether. 10^18 wei = 1 ether.

Zero address

A special Ethereum address, composed entirely of zeros, is specified as the destination address of a contract creation transaction.


Alchemy Web3

Alchemy Web3 is a drop-in replacement for web3.js, built and configured to work seamlessly with Alchemy and provide multiple advantages such as automatic retries and robust WebSocket support. See the Alchemy web3 page to learn more.

Compute Units (CUs)

Compute units or CUs represent the cost associated with given API calls. See the Compute Units page to learn more.

Rate Limit

Rate limit is the cap on FCUs permitted. See the Rate Limit page to learn more.


Computational infeasibility

A process is computationally infeasible if it would take an impractically long time (eg. billions of years) to do it for anyone who might conceivably have an interest in carrying it out. Generally, 280 computational steps is considered the lower bound for computational infeasibility.

Digital Signature

A digital signature is a virtual signing algorithm in a process by which a user can produce a short string of data called a “signature” of a document using a private key. With this signature, the corresponding public key, and the relevant document, anyone can verify that:

  1. The document was “signed” by the owner of that particular private key.
  2. The document was not changed after it was signed.

Note that this differs from traditional signatures where you can scribble extra text onto a document after you sign it and there’s no way to tell the difference; in a digital signature any change to the document will render the signature invalid.


Elliptic Curve Digital Signature Algorithm. A cryptographic algorithm used by Blockchains to ensure that funds can only be spent by their owners.


Encryption is a process by which a document (plaintext) is combined with a shorter string of data, called a key, to produce an output (ciphertext) which can be “decrypted” back into the original plaintext by someone else who has the key, but which is incomprehensible and computationally infeasible to decrypt for anyone who does not have the key.


In cryptography, entropy is used to produce randomness. This randomness of strings or numbers are used to produce security keys to protect data while it's in storage or in transit. The greater the quality of randomness, the greater the quality of random keys produced, and thus the higher the security value of the key. Entropy is used to ensure an output is unpredictable.


A hash function (or hash algorithm) is a process by which a piece of data of arbitrary size (could be anything; a piece of text, a picture, or even a list of other hashes) is processed into a small piece of data (usually 32 bytes). This smaller piece of data looks completely random and you cannot recover any meaningful information about the original data from it, however, it has the important property that the result of hashing one particular document is always the same.

Additionally, it is crucially important that it is computationally infeasible to find two documents that have the same hash. Generally, changing even one letter in a document will completely randomize the hash; for example, the SHA3 hash of “Saturday” is c38bbc8e93c09f6ed3fe39b5135da91ad1a99d397ef16948606cdcbd14929f9d, whereas the SHA3 hash of "Caturday" is b4013c0eed56d5a0b448b02ec1d10dd18c1b3832068fbbdc65b98fa9b14b6dbf. Hashes are usually used as a way of creating a globally agreed-upon identifier for a particular document that cannot be forged.


The keccak-256 algorithm computes the hash of an input to a fixed length output. The input can be a variable length string or number, but the result will always be a fixed bytes32 data type. It is a one-way cryptographic hash function, which cannot be decoded in reverse.


In Ethereum, every transaction from an EOA contains a number called a nonce. The nonce is the number of transactions sent from a given address. In English, a nonce is defined as a number that can only be used once.

Private (Secret) Key

The secret value that allows Ethereum users to prove ownership of an account or contract, by producing a digital signature.

Public Key Encryption

Public-key encryption is a special kind of encryption where there is a process for generating two keys at the same time (typically called a private key and a public key), such that documents encrypted using one key can be decrypted with the other. Generally, as suggested by the name, individuals publish their public keys and keep their private keys to themselves.


Secure Hashing Algorithm. SHA is a modified version of MD5 and used for hashing data and certificates. It works by transforming data using a hash function

Smart Contracts


An Event enables the logging capabilities of the EVM. Smart Contracts emit events which can be accessed via RPC methods.

Internal Transactions

Internal transactions are transactions that occur between smart contracts. This can also include transactions from a smart contract to an external address when sending ETH to a user. These transactions are labeled internal because every deployed smart contract on the Ethereum blockchain has an assigned internal address.


For smart contracts, oracles are a middle-ware product in which data outside of the blockchain (such as real-world data from weather to stocks) is connected to it. That data is then used for conditions of smart contracts. Ethereum is self-contained, so oracles would allow smart contracts to branch out into real-world applications by bringing the data to it. An example of this would be sports betting, where a smart contract would be resolved by receiving the scores of a sporting event. Vitalik Buterin wrote an article about oracles and how they could be used with Ethereum.


Self-executing means it can function by itself, not controlled by any other party. Self-executing smart contracts would cut costs/overhead by removing the need for an arbitrator and trust in a third party.

Smart contract

A smart contract is a computer protocol meant to streamline the process of contracts by digitally enforcing, verifying, or otherwise managing them. Given the nature of the blockchain, all of these transactions are visible and verifiable through the code itself. Smart contracts were first proposed in 1994 by Nick Szabo, an early contributor to Bitcoin.

You can think of a smart contract as a vending machine; you give it enough money (gas) and it will process a transaction for you.


Trustless means that it does not require a third party to verify or manage. Smart contracts are primarily trustless, as they are meant to occur by themselves once the stipulations are met.

Casper and Scaling Research

Censorship Fault

A censorship fault is a validator failing to accept valid messages from another validator.

Data Availability

Data availability is the property of a state that any node connected to the network could download any specific part of the state that they wish to download.

Data availability problem and Fisherman’s dilemma

See https://github.com/ethereum/research/wiki/A-note-on-data-availability-and-erasure-coding

Economic finality

A block or state can be considered economically finalized if a client has proof that either

  1. The block is going to be part of the canonical chain forever or
  2. Those actors that caused the block to get reverted are guaranteed to be economically penalized by an amount equal to at least $X.

This value X is called the cryptoeconomic security margin of the finality mechanism.


An equivocation occurs when a validator sends two messages that contradict each other. More precisely, when a validator sends two messages that a validator running the correct algorithm could only send if it sends one message, “rewinds” its internal state to some point before sending that message, then at some future point in time sends the other message. One simple example is a transaction sender sending two transactions with the same nonce.


A fault is an action taken by a validator (or more generally, a participant in a mechanism) that they would not have taken had they correctly followed the protocol.

Fraud Proof

Fraud proof is a set of data, usually, a part of a block plus some extra “witness data” (eg. Merkle branches), that can be used to prove that a given block is invalid.

Invalidity Fault

An invalidity fault is a validator sending a message that a computer running the correct algorithm could not possibly send, unless its internal state is manipulated with in some way other than rewinding.

Liveness Fault

A liveness fault is a validator failing to submit a message that according to the protocol they should have submitted (or submitting a message later than they should have).

Loose Coupling

Chains A and B are loosely coupled if:

  1. Any state of A points to some state of B (and vice versa)
  2. They are not tightly coupled.

Prepare and Commit

Prepare and commit are two types of messages that validators can send in many types of consensus protocols; see https://medium.com/@VitalikButerin/minimal-slashing-conditions-20f0b500fc6c..

Proof of Stake

A method by which a cryptocurrency blockchain protocol aims to achieve distributed consensus. PoS asks users to prove ownership of a certain amount of cryptocurrency (their "stake" in the network) in order to be able to participate in the validation of transactions.

Security Deposit

A security deposit is a quantity of ether that a user deposits into a mechanism (often a proof of stake consensus mechanism, though this can also be used for other applications) that a user expects to be able to eventually withdraw and recover, but which can be taken away in the event of malfeasance from the user’s side.

Slashing Condition

The slashing condition is a condition that, if triggered by a validator, causes the validator’s deposit to be destroyed.


A shard is a subset of the state which is managed by different nodes from the nodes that manage other shards. Usually, shards must be tightly coupled, and sidechains must be loosely coupled.

Tight Coupling

Chains A and B are tightly coupled if:

  1. Any state of A points to some state of B (and vice versa)
  2. A state of A should not be considered admissible unless both that state itself and the state of B that it points to are valid and data-available.

Uniquely attributable fault

A uniquely attributable fault is a fault such that there exists clear evidence which can be used to determine exactly which validator committed the fault. For example, liveness faults are not uniquely attributable because if a message from A fails to reach B, it could be because A failed to send that message, or because B failed to listen to it, whereas equivocation faults are uniquely attributable.


A validator is a participant in proof of stake consensus. Validators need to submit a security deposit in order to get included in the validator set.


Validity is the property of a state that it is indeed the result of executing a valid history of transactions.


Solidity, LLL, Serpent and Vyper

These are programming languages for writing contract code which can be compiled into EVM code.

  • Serpent and Vyper are Python-like languages (the developer of the two currently recommends Vyper more)
    • Serpent can also be compiled into LLL (Lisp Like Language)
  • Solidity is a C+± like language (and is the most widely used)


Swarm is an upcoming P2P data storage protocol optimized for static web hosting.


Proof-of-concept, another name for a pre-launch release.


Whisper is an upcoming P2P messaging protocol.