Advanced Blockchain Glossary — 50 Technical Terms for Developers

ABI (Application Binary Interface)

The JSON specification describing a smart contract's functions, parameters, and return types. Required by Web3 libraries (viem, ethers.js) to encode function calls and decode return values. Without the ABI, a calling contract cannot interact with the target.

Account Abstraction (ERC-4337)

A protocol allowing smart contracts to act as user accounts — enabling batch transactions, sponsored gas, session keys, and social recovery without a protocol fork. The EntryPoint contract singleton at 0x5FF1...0C7D coordinates user operation execution.

Attestation

A signed statement by a trusted party that something is true. 'This address passed KYC' is an attestation. In blockchain: attestations can be on-chain (gas cost, permanent) or off-chain (free, linkable via signature verification).

Bundler (ERC-4337)

A node that collects UserOperations from the alternative mempool, simulates their execution, and submits valid bundles as a single Ethereum transaction. Bundlers earn fees from the UserOperations they process.

Cairo

The native programming language of StarkNet, a ZK-rollup. Not compatible with Solidity — requires learning a new language. Provides powerful zero-knowledge proof generation capabilities not available in EVM contracts.

Calldata

Immutable, non-modifiable input data sent with a transaction. Reading calldata (`CALLDATALOAD`) costs less gas than reading memory (`MLOAD`). Passing arguments as `calldata` instead of `memory` in external functions reduces gas cost.

Canonicalization

Converting data to a standard form before signing, to ensure the same data always produces the same bytes. Important in multi-party signing (MPC, multi-sig) where two parties must sign identical byte representations.

CCIP (Chainlink Cross-Chain Interoperability Protocol)

Chainlink's general-purpose cross-chain messaging and token transfer protocol. Used for bridging tokens and sending arbitrary messages between chains with Chainlink's oracle security model.

Circuit (ZK)

The mathematical constraint system that defines what a zero-knowledge proof proves. Writing a ZK circuit is analogous to writing a smart contract — but expresses constraints rather than sequential logic. ZK circuit languages: Circom, Noir, Cairo.

CometBFT (formerly Tendermint)

The Byzantine Fault Tolerant consensus algorithm used by Cosmos SDK blockchains. Provides instant finality (no probabilistic finality) — once a block is committed, it is final. Used by dYdX v4, Injective, and other Cosmos appchains.

Composable

A DeFi protocol component designed to be integrated with other protocols. aTokens (Aave) are composable — they can be used as collateral in other protocols because they follow the ERC-20 standard. Non-composable components require custom adapters.

Confirmations

The number of blocks added after the block containing a transaction. More confirmations = lower probability of reorganization. 1 confirmation: transaction is in a block. 12 confirmations: extremely low reorganization probability on Ethereum.

Constant Product (x·y=k)

The mathematical invariant of Uniswap V2's AMM. At any point: tokenA_reserve × tokenB_reserve = constant k. Trades move along this curve, with price determined by the current pool ratio.

Delegatecall

A low-level EVM operation where the called contract's code executes in the calling contract's storage context. Fundamental to proxy patterns (the proxy stores state; the implementation provides logic via delegatecall). A critical security concern: the implementation contract must not have storage that collides with the proxy's storage.

Deterministic Wallet (HD Wallet)

A wallet that derives all key pairs from a single master seed. BIP32 defines the derivation path structure (`m/44'/60'/0'/0/0` for the first Ethereum address). A single 12-24 word seed phrase recovers all derived keys.

Diamond Pattern (EIP-2535)

A proxy architecture allowing a single contract address to delegate to multiple implementation contracts (called 'facets'). Enables upgradeability without the storage layout constraints of UUPS — each facet can add new storage. Used for complex protocols that exceed the 24KB contract size limit.

EIP (Ethereum Improvement Proposal)

The formal specification process for proposed Ethereum protocol changes. Status flow: Idea → Draft → Review → Last Call → Final. ERCs (Ethereum Request for Comments) are EIPs defining application-level standards (token interfaces).

Endgame (Ethereum)

Vitalik Buterin's long-term Ethereum roadmap: the Merge (done), the Surge (rollup scaling via EIP-4844), the Scourge (MEV reduction), the Verge (Verkle trees for statelessness), the Purge (history expiry), the Splurge (miscellaneous). Each phase improves scalability, security, or decentralization.

Entrypoint (ERC-4337)

The singleton smart contract at `0x5FF1...0C7D` on all EVM chains that coordinates UserOperation validation and execution. All ERC-4337 smart accounts interact through this single entrypoint.

ERC-4626 (Tokenized Vault Standard)

A standard interface for yield-bearing tokens. deposit(), withdraw(), convertToShares(), convertToAssets(). Enables yield-bearing positions to be composable with other DeFi protocols.

Ethereum Virtual Machine (EVM)

The sandboxed computation environment where Ethereum smart contracts execute. All EVM-compatible chains (Polygon, Arbitrum, Optimism, BNB Chain) share the same instruction set — Solidity compiles to the same bytecode for all of them.

Event (Solidity)

A log emitted by a smart contract and recorded in the transaction receipt. Events are cheaper to store than storage writes. They are not accessible from within the contract but are queryable off-chain via `eth_getLogs` or The Graph. `emit Transfer(from, to, amount)` is the canonical ERC-20 event.

Execution Layer (Ethereum)

The client responsible for processing transactions and maintaining the EVM state (Geth, Erigon, Nethermind, Besu). Post-Merge, it pairs with a consensus layer client (Prysm, Lighthouse) to run a full Ethereum node.

Facet (Diamond Pattern)

An implementation contract in the Diamond pattern that provides specific functionality. A Diamond proxy can delegate to 100+ facets, each handling different aspects of protocol logic.

Fee Tier (Uniswap V3)

LP positions are created in specific fee tiers: 0.01%, 0.05%, 0.30%, or 1.00%. Each fee tier is a separate pool. Liquidity fragmented across fee tiers results in each pool having less depth but the aggregated swap router finds the best price.

Fork Choice Rule

The algorithm validators use to determine which fork of the blockchain is canonical when multiple competing forks exist. Ethereum's post-Merge fork choice: LMD-GHOST (Latest Message Driven Greediest Heaviest Observed SubTree).

Forking (EVM)

Foundry's ability to create a local fork of any EVM chain at any block height. Allows testing against real production state: `vm.createFork('https://eth-mainnet.g.alchemy.com/v2/KEY')`. Essential for testing integrations with existing DeFi protocols.

Foundry (forge/cast/anvil)

The modern Solidity development toolkit. forge: builds, tests, and deploys contracts. cast: command-line Ethereum interactions. anvil: local EVM testnet with instant mining. The production standard for smart contract development.

Hardhat

A Solidity development framework using JavaScript/TypeScript for tests and deployment scripts. Preceded Foundry; still widely used. Slower than Foundry but has a larger ecosystem of plugins and better Hardhat Ignition for complex deployments.

Hook (Uniswap V4)

Uniswap V4's extensibility mechanism allowing custom logic to execute at defined lifecycle points (beforeSwap, afterSwap, beforeAddLiquidity, etc.). Enables custom fee models, TWAP oracles, and protocol-specific behavior without forking.

Immutable (Solidity)

A variable set once at construction and stored directly in the contract bytecode (not storage). Reading an `immutable` variable costs less gas than reading a storage variable because it's embedded in the code.

Initializer (Upgradeable Contracts)

The function that replaces the constructor in upgradeable proxy contracts. Marked with `initializer` modifier from OpenZeppelin. Can only be called once. Must manually call `__ERC20_init()`, `__Ownable_init()`, etc. for upgradeable base contracts.

Invariant (Foundry Testing)

A property that must hold true after any sequence of operations. Foundry invariant tests (`invariant_*` functions) run thousands of random operation sequences to verify. Example: `invariant_totalSupplyEqualsBalanceSum()` verifies ERC-20 accounting.

IPNS (InterPlanetary Name System)

A mutable naming layer on top of IPFS. An IPNS address points to the latest version of content (the CID can change). Contrast with IPFS CIDs which are immutable (same CID forever for same content).

Isolated Margin

Derivatives trading mode where each position has its own dedicated collateral. Losses limited to that position's collateral. Contrast with cross-margin where all positions share a single collateral pool.

Keystore File

An encrypted JSON file containing an Ethereum private key, protected by a password. Standard format for software wallet key storage. Less secure than hardware wallet but better than plaintext private key storage.