This quick glossary contains many terms related to Ethereum. These terms are used throughout this book, so please bookmark them for quick reference.
Account Account
An object containing an address, balance, nonce, and optionally storage and code. An account can be a contract account or an externally owned account (EOA, externally owned account).
AddressAddress
Generally speaking, this represents an EOA or contract, which can receive (destination address) or send (source address) transactions on the blockchain. More specifically, it is the rightmost 160 bits of the Keccak hash of the ECDSA public key, represented as 40 characters in hexadecimal, preceded by the "0x" character.
Assert
In Solidity, assert(false) compiles to 0xfe , an invalid opcode that uses up all remaining Gas and reverts all changes. When an assert() statement fails, something serious went wrong or an exception occurred, and you must fix your code. You should use assert to avoid conditions that should never occur.
Big-endian Big-endian
A positional representation of a value with the most significant bit first. Corresponds to little-endian, with the least significant bit first.
Bitcoin Improvement Proposals (BIPs)
Bitcoin Improvement Proposals, Bitcoin Improvement Proposals. A set of proposals submitted by members of the Bitcoin community to improve Bitcoin. For example, BIP-21 is a proposal to improve Bitcoin's Uniform Resource Identifier (URI) scheme.
Block Block
A block is a collection of required information (block headers) about the transactions it contains, along with a set of other block headers called ommers. It is added to the Ethereum network by miners.
Blockchain Blockchain
A series of blocks validated by the proof-of-work system, each block connected to its predecessors, all the way to the genesis block. This differs from the Bitcoin protocol in that it has no block size limit; it uses a different gas limit instead.
Byzantium Fork
Byzantium is one of the two forks in the development phase of the Metropolis. It includes EIP-649: Metropolitan Difficulty Bomb Delay and Block Reward Reduction, where the Ice Age (see below) is delayed by 1 year and the block reward is reduced from 5 ETH to 3 ETH.
Compiling
Convert code written in a high-level programming language (such as Solidity) to a low-level language (such as EVM bytecode)
Consensus
A situation where a large number of nodes, typically a majority of nodes on the network, have the same block in their locally validated best blockchain. Not to be confused with consensus rules.
Consensus rules
In order to be consistent with other nodes, full nodes follow the block verification rules. Not to be confused with consensus.
Constantinople
The second part of the Metropolitan phase, planned for the mid-2018 period. Expected to include a switch to a hybrid proof-of-work/proof-of-stake consensus algorithm, among other changes.
Contract accountContract account
An account containing code to execute whenever it receives a transaction from another account (EOA or contract).
Contract creation transaction Contract creation transaction
A special transaction, with "zero address" as recipient, is used to register the contract and record it in the Ethereum blockchain (see "zero address").
Decentralized Autonomous Organization DAO
Decentralized Autonomous Organization Decentralized Autonomous Organization. Companies and other organizations without hierarchical management. It may also refer to the April 30, 2016 release of a contract called "The DAO", which was hacked in June 2016, culminating in a hard fork (codenamed DAO) at block 1,192,000 , restored the hacked DAO contract, and resulted in two competing systems, Ethereum and Ethereum Classic.
Decentralized application DApp
Decentralized Application Decentralized Application. In a narrow sense, it is at least a smart contract and a web user interface. More broadly, a DApp is a web application based on an open, decentralized, peer-to-peer infrastructure service. Additionally, many DApps include decentralized storage and/or messaging protocols and platforms.
Contract Deed
The non-replaceable token standard is introduced in the ERC721 proposal. Unlike ERC20 tokens, deeds prove ownership and are not fungible, although they are not yet recognized as legal documents in any jurisdiction, at least not yet.
Difficulty
A network-wide setting that controls how much computation is required to produce a proof of work.
Digital signatureDigital signature
A digital signature algorithm is a process by which a user uses a private key to generate a short string of data called a "signature" for a document, so that anyone with the signature, the document, and the corresponding public key, can verify (1) that the document was created by the The owner of the particular private key "signs", and (2) the document has not been altered since it was signed.
Elliptic Curve Digital Signature Algorithm ECDSA
The Elliptic Curve Digital Signature Algorithm (ECDSA) is an encryption algorithm used by Ethereum to ensure that funds can only be used by legitimate owners.
Ethereum Improvement Proposal EIP
Ethereum Improvement Proposals, Ethereum Improvement Proposals, describe proposed standards for the Ethereum platform. An EIP is a design document that provides information to the Ethereum community, describing a new feature, or process, or environment. See https://github.com/ethereum/EIPs for more information (see also ERC definition below).
Entropy Entropy
In cryptography, a lack of predictability or level of randomness. When generating secret information such as a master private key, algorithms often rely on high-entropy sources to ensure that the output is unpredictable.
Ethereum Name Service ENS
Ethereum Name Service, Ethereum Name Service. For more information, see https://github.com/ethereum/ens/ .
Externally Owned Account EOA
Externally Owned Account. An account created by or for a real user of Ethereum.
Ethereum comment request ERC
Ethereum Request for Comments. Some EIPs are marked as ERC, denoting proposals that attempt to define specific standards used by Ethereum.
Ethash
Ethereum 1.0's proof-of-work algorithm. For more information, see https://github.com/ethereum/wiki/wiki/Ethash .
Ether
Ether, the native currency used in the Ethereum ecosystem, bears gas costs when executing smart contracts. Its match is Ξ, the uppercase Xi character for geeks.
Event
Events allow the use of EVM logging facilities, which can be used to call JavaScript callbacks in the DApp's user interface to listen for these events. See http://solidity.readthedocs.io/en/develop/contracts.html#events for more information .
Ethereum Virtual Machine EVM
Ethereum Virtual Machine, a stack-based virtual machine that executes bytecode. In Ethereum, the execution model specifies how the state of the system changes given a sequence of bytecode instructions and a small amount of environmental data. This is specified through a formal model of the virtual state machine.
EVM Assembly LanguageEVM Assembly Language
Human-readable form of bytecode.
Fallback method Fallback function
The default method to execute when data or the declared method name is missing.
Faucet
A website that offers rewards in the form of free testing ether for developers who want to test on the testnet.
Frontier
The experimental development phase of Ethereum, from July 2015 to March 2016.
Ganache
A private ethereum blockchain on which you can test, execute commands, check status while controlling how the blockchain works.
Gas
The virtual gas used by Ethereum to execute smart contracts. The Ethereum Virtual Machine uses an accounting mechanism to measure gas consumption and limit the consumption of computing resources. See "Turing completeness". Gas is the unit of calculation generated for each instruction that executes a smart contract. Gas is pegged to the ether cryptocurrency. Gas is similar to airtime on a cellular network. Therefore, the price of a transaction in fiat currency is gas (ETH /gas) (fiat currency / ETH).
Gas limit Gas limit
When talking about blocks, they also have an area called gas limit. It defines the maximum amount of gas that all transactions in the entire block are allowed to consume.
Genesis block
The first block in the blockchain, used to initialize a specific network and encrypted digital currency.
Geth
Ethereum in Go. One of the most prominent implementations of the Ethereum protocol written in Go.
Hard fork Hard fork
A hard fork, also known as a hard fork change, is a permanent divergence in a blockchain that typically occurs when non-upgraded nodes are unable to validate blocks created by upgraded nodes that follow the new consensus rules. Not to be confused with forks, soft forks, software forks, or Git forks.
Hash value
Fixed-length fingerprints generated by hashing for data of variable size.
Hierarchical determination of wallet HD wallet
A wallet using a layered deterministic key generation and transfer protocol (BIP32).
Hierarchically determine the wallet seed HD wallet seed
The HD wallet seed or root seed is a possibly short value used as the seed for generating the HD wallet's master private key and master chaincode. Wallet seeds can be represented by mnemonic words, making it easier for people to copy, backup and restore private keys.
HomesteadHomestead
The second development phase of Ethereum, which was launched at block 1,150,000 in March 2016.
Ice Age Ice Age
Ethereum’s hard fork at block 200,000, proposing an exponential increase in difficulty (aka the difficulty bomb), triggered the transition to Proof-of-Stake.
Integrated Development Environment IDE (Integrated Development Environment)
Integrated user interface combining code editor, compiler, runtime and debugger.
Immutable Deployed Code Problem Immutable Deployed Code Problem
Once the code for a contract (or library) is deployed, it becomes immutable. Fixing possible bugs and adding new features is the crux of the software development cycle. This is a challenge for smart contract development.
Inter exchange Client Address Protocol (ICAP)
Ethereum address encoding, which is partially compatible with the International Bank Account Number (IBAN) encoding, provides a diverse, checksum, and interoperable encoding for Ethereum addresses. An ICAP address can encode an Ethereum address or a common name registered through the Ethereum Name Registry. They always start with XE. Its purpose is to introduce a new IBAN country code: XE, where the X stands for "extended", plus the E for Ethereum, for non-jurisdictional currencies (e.g. XBT, XRP, XCP).
Internal transaction (also "message")
A transaction sent from one contract address to another contract address or EOA.
Keccak256
The cryptographic hashing method used by Ethereum. Although written as SHA-3 in the early Ethereum code, Keccak256 is different from the standard NIST-SHA3 because NIST adjusted the padding algorithm when SHA-3 was standardized in August 2015. Ethereum also began to replace SHA-3 with Keccak256 in subsequent codes.
Key derivation method Key Derivation Function (KDF)
Also known as the password expansion algorithm, it is used by the keystore format to prevent brute force, dictionary or rainbow table attacks on password encryption. It repeatedly hashes the password.
Keystore file
JSON-encoded file containing a (randomly generated) private key, encrypted with a passphrase for extra security.
LevelDB
LevelDB is an open source disk key-value storage system. LevelDB is a lightweight, single-target persistence library that supports many platforms.
LibraryLibrary
Libraries in Ethereum are special types of contracts that have no methods for payments, no fallback methods, and no data storage. So it cannot receive or store ether, or store data. Libraries are used as previously deployed code, and other contracts can invoke read-only computations.
Lightweight client Lightweight client
A lightweight client is an Ethereum client that does not store a local copy of the blockchain and does not validate blocks and transactions. It provides the functionality of a wallet to create and broadcast transactions.
Message Message
Internal transactions, never serialized, only sent in the EVM.
Metropolis Stage
Metropolis is the third development phase of Ethereum, launched in October 2017.
METoken
Mastering Ethereum Token. The ERC20 token used for demonstration purposes in this book.
Miner
Find valid proof-of-work network nodes for new blocks by repeating hash calculations.
Mist
Mist is the first Ethereum browser created by the Ethereum Foundation. It also includes a browser-based wallet, the first implementation of the ERC20 token standard (Fabian Vogelsteller, author of ERC20 and lead developer of Mist). Mist is also the first wallet to introduce the camelCase checksum (EIP-155). Mist runs a full node, provides a full DApp browser, supports Swarm-based storage and ENS addresses
Network Network
Propagate transactions and blocks to a peer-to-peer network of every Ethereum node (network participant).
NodeNode
A software client that participates in a peer-to-peer network.
Random number Nonce
In cryptography, a random number refers to a value that can only be used once. Two types of random numbers are used in Ethereum.
Account Nonce - This is just a transaction count for an account.
Proof-of-Work nonce - A random value in the block used to obtain Proof-of-Work (depending on the difficulty at the time).
Ommer
A child node of a grandparent node, but not itself a parent node. By the time a miner finds a valid block, another miner may have published a competing block and added it to the top of the blockchain. Like Bitcoin, orphaned blocks in Ethereum can be included as ommers by new blocks and receive a partial reward. The term "ommer" is a gender-neutral term for sibling nodes of a parent node, but can also mean "uncle".
Parity
One of the most prominent implementations of Ethereum client software supporting interoperability (multi-signature).
Proof-of-Stake (PoS)
Proof-of-stake is a method by which cryptocurrency blockchain protocols aim to achieve distributed consensus. Proof-of-stake requires users to prove ownership of a certain amount of cryptocurrency ("stakes" in the network) in order to be able to participate in transaction validation.
Proof-of-Work (PoW)
A piece of data (proof) that requires a lot of computation to find. In Ethereum, miners must find a numerical solution to the Ethash algorithm that meets the network difficulty target.
Receipt
Data returned by an Ethereum client representing the outcome of a particular transaction, including the hash of the transaction, its block number, the amount of gas used, and the address of the contract when the smart contract was deployed.
Re-entrancy Attack Re-entrancy Attack
This attack can be repeated when the Attacker contracts call methods of the Victim contracts. Let's call it victim.withdraw(), and before the original call to the contract function completes, the victim.withdraw() method is called again, continuing to call itself recursively. Recursive calls can be made through fallback methods of the attacker contract. The only trick the attacker has to perform is to interrupt the recursive call before running out of gas and avoiding the stolen ether from being restored.
Require
In Solidity, require(false) compiles to 0xfd , which is the REVERT opcode. The REVERT instruction provides a way to stop execution and resume state changes without consuming all provided gas and being able to return the reason. The require function should be used to ensure valid conditions are met, such as input or contract state variables, or to validate return values from calls to external contracts. Before the *Byzantine* network was upgraded, there were two practical ways to revert transactions: running out of gas or executing invalid instructions. Both options consume all remaining gas. Before the *Byzantium* network upgrade, this opcode could not be found in the *yellow book*, and since the opcode was not specified, an invalid opcode error would be thrown when the EVM executed it .
Revert Revert
Use revert() when you need to handle the same cases as require() , but with more complex logic. For example, if your code has some nested if/else logic flow, you may find it reasonable to use require() instead of require().
Rewards
Amount of Ether (ETH), the amount included in each new block as the network's reward to miners who find a proof-of-work solution.
Recursive Length Prefix (RLP)
RLP is an encoding standard designed by Ethereum developers to encode and serialize objects (data structures) of arbitrary complexity and length.
Satoshi Nakamoto
Satoshi Nakamoto is the name of the individual or team that designed Bitcoin and its original implementation, Bitcoin Core. As part of their implementation, they also designed the first blockchain. In the process, they were the first to solve the double-spend problem for digital currencies. Their true identities remain a mystery to this day.
Vitalik Buterin
Vitalik Buterin is a Russian-Canadian programmer and writer, co-founder of Ethereum and Bitcoin Magazine.
Gavin Wood
Gavin Wood is a UK-based programmer, co-founder and former CTO of Ethereum. In August 2014 he proposed Solidity, a contract-oriented programming language for writing smart contracts.
Secret key (aka private key)
A cryptographic number that allows Ethereum users to prove ownership of an account or contract by creating a digital signature (see public key, address, ECDSA).
SHA
Secure Hash Algorithm, SHA is a series of cryptographic hash functions released by the National Institute of Standards and Technology (NIST).
SELFDESTRUCT opcode
Smart contracts will exist and be enforceable as long as the entire network exists. If they are programmed to self-destruct or use a delegatecall or callcode to do so, they will disappear from the blockchain. Once the self-destruct operation is performed, the remaining Ether stored at the contract address will be sent to another address and the storage and code will be removed from the state. Although this is expected behavior, pruning of self-destructing contracts may or may not be implemented by Ethereum clients. SELFDESTRUCT was previously called SUICIDE, and in EIP6, SUICIDE was renamed to SELFDESTRUCT.
Serenity
The fourth and final development phase of Ethereum. Serenity has no planned release date yet.
Serpent
A procedural (imperative) programming language with a syntax similar to Python. It can also be used to write functional (declarative) code, although it is not completely side-effect free. First created by Vitalik Buterin.
Smart ContractSmart Contract
Programs executed on Ethereum's computing framework.
Solidity
A procedural (imperative) programming language with a syntax similar to Javascript, C++ or Java. The most popular and commonly used language for Ethereum smart contracts. First created by Gavin Wood (co-author of this book)
Solidity inline assembly
Inline assembly Code contained in Solidity that uses EVM assembly (the human-readable form of EVM code). Inline assembly attempts to solve the inherent difficulties and other problems encountered when manually writing assembly.
Spurious Dragon
Hard fork at block #2,675,00 to address more denial of service attack vectors, and another state purge. There is also a rebroadcast attack protection mechanism.
Swarm
A decentralized (P2P) storage network. Works with Web3 and Whisper to build DApps.
Tangerine Whistle
Hard fork at block #2,463,00 that changes how gas is computed for certain I/O intensive operations and clears accumulated state from denial of service attacks that take advantage of the low gas cost of these operations.
Testnet Testnet
A test network (testnet for short) that simulates the behavior of the main Ethereum network.
Transaction Transaction
Data submitted to the Ethereum blockchain signed by the original account and targeted to a specific address. Transactions contain metadata such as the gas limit for the transaction.
Truffle
One of the most commonly used Ethereum development frameworks. Contains some NodeJS packages that can be installed using the Node Package Manager (NPM).
Turing Complete Turing Complete
In the theory of computation, it is called Turing-complete or computationally universal if the rules for data manipulation (such as a computer's instruction set, programming language, or cellular automata) can be used to simulate any Turing machine. The concept is named after British mathematician and computer scientist Alan Turing.
Vyper
A high-level programming language, Serpent-like, with a Python-like syntax that aims to approach a purely functional language. First created by Vitalik Buterin.
WalletWallet
The software that holds all your keys. Serves as an interface to access and control Ethereum accounts and interact with smart contracts. Note that keys do not need to be stored in your wallet and can be retrieved from offline storage such as a USB flash drive or paper for added security. Despite the wallet name, it never stores actual coins or tokens.
Web3
The third version of the web. First proposed by Gavin Wood, Web3 represents a new vision and focus for web applications: from centrally owned and managed applications to decentralized protocol-based applications.
Wei
The smallest unit of ether, 10 18 wei = 1 ether.
Whisper
A decentralized (P2P) messaging system. Use with Web3 and Swarm to build DApps.
Zero address Zero address
A special Ethereum address, all composed of 0s (that is, 0x000000000000000000000000000000000000000 ), is designated as the target address (that is , the value of the to parameter ) of the transaction (Transaction) initiated by creating a smart contract .